[์๋ฐ ORM ํ์ค JPA ํ๋ก๊ทธ๋๋ฐ - ๊น์ํ]์ ์ฝ๊ณ ์ธ์ฉํ๊ณ ์ ๋ฆฌํ๋ POST์ ๋๋ค.
JPQL์ ๊ฐ์ฅ ์ค์ํ ๊ฐ์ฒด์งํฅ ์ฟผ๋ฆฌ ์ธ์ด์ด๋ค.
๐ซ ๊ฐ์ฒด์งํฅ ์ฟผ๋ฆฌ ์๊ฐ
em.find() ๋ฉ์๋๋ฅผ ์ฌ์ฉํด ์๋ณ์๋ก ์ํฐํฐ ํ๋๋ฅผ ์กฐํํ ์ ์๋ค. ์ด๋ ๊ฒ ์กฐํํ ์ํฐํฐ์ ๊ฐ์ฒด ๊ทธ๋ํ ํ์์ ์ฌ์ฉํ๋ฉด ์ฐ๊ด๋ ์ํฐํฐ๋ค์ ์ฐพ์ ์ ์๊ณ , ์๋๋ ๊ฐ์ฅ ๋จ์ํ ๊ฒ์ ๋ฐฉ๋ฒ์ด๋ค.
- ์๋ณ์๋ก ์กฐํ -
em.find() - ๊ฐ์ฒด ๊ทธ๋ํ ํ์ -
a.getB().getC()
ORM์ ์ฌ์ฉํ๋ฉด ๋ฐ์ดํฐ๋ฒ ์ด์ค ํ ์ด๋ธ์ด ์๋ ์ํฐํฐ ๊ฐ์ฒด๋ฅผ ๋์์ผ๋ก ๊ฐ๋ฐํ๋ฏ๋ก ๊ฒ์๋ ํ ์ด๋ธ์ด ์๋ ์ํฐํฐ ๊ฐ์ฒด๋ฅผ ๋์์ผ๋ก ํ๋ ๋ฐฉ๋ฒ์ด ํ์ํ๋ค. JPQL์ ์ด๋ฐ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด ๋ง๋ค์ด์ ธ์ ์๋์ ํน์ง์ด ์๋ค.
- ํ ์ด๋ธ์ด ์๋ ๊ฐ์ฒด๋ฅผ ๋์์ผ๋ก ๊ฒ์ํ๋ ๊ฐ์ฒด์งํฅ ์ฟผ๋ฆฌ๋ค.
- SQL์ ์ถ์ํํด์ ํน์ ๋ฐ์ดํฐ๋ฒ ์ด์ค SQL์ ์์กดํ์ง ์๋๋ค.
SQL์ด "๋ฐ์ดํฐ๋ฒ ์ด์ค ํ ์ด๋ธ์ ๋์์ผ๋ก ํ๋ ๋ฐ์ดํฐ ์ค์ฌ์ ์ฟผ๋ฆฌ"๋ผ๋ฉด, JPQL์ "์ํฐํฐ ๊ฐ์ฒด๋ฅผ ๋์์ผ๋ก ํ๋ ๊ฐ์ฒด์งํฅ ์ฟผ๋ฆฌ"๋ค. JPQL์ ์ฌ์ฉํ๋ฉด JPA๋ ์ด JPQL์ ๋ถ์ํ ๋ค์ ์ ์ ํ SQL์ ๋ง๋ค์ด ๋ฐ์ดํฐ๋ฒ ์ด์ค๋ฅผ ์กฐํํ๊ณ , ์กฐํํ ๊ฒฐ๊ณผ๋ก ์ํฐํฐ ๊ฐ์ฒด๋ฅผ ์์ฑํด์ ๋ฐํํ๋ค.
JPA๋ JPQL๋ฟ๋ง ์๋๋ผ ๋ค์ํ ๊ฒ์ ๋ฐฉ๋ฒ์ ์ ๊ณตํ๊ณ , ์๋๋ JPA๊ฐ ๊ณต์ ์ง์ํ๋ ๊ธฐ๋ฅ์ด๋ค.
- JPQL(Java Persistence Query Language)
- Criteria ์ฟผ๋ฆฌ: JPQL์ ํธํ๊ฒ ์์ฑํ๋๋ก ๋์์ฃผ๋ API, ๋น๋ ํด๋์ค ๋ชจ์์ด๋ค.
- ๋ค์ดํฐ๋ธ SQL: JPA์์ JPQL ๋์ ์ง์ SQL์ ์ฌ์ฉํ ์ ์๋ค.
โฐ JPQL ์๊ฐ
JPQL์ ์ํฐํฐ ๊ฐ์ฒด๋ฅผ ์กฐํํ๋ ๊ฐ์ฒด์งํฅ ์ฟผ๋ฆฌ๋ค. SQL์ ์ถ์ํํด์ ํน์ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ์์กดํ์ง ์๋๋ค.
- ๋ฌธ๋ฒ์ SQL๊ณผ ๋น์ทํ๊ณ ANSI ํ์ค SQL์ด ์ ๊ณตํ๋ ๊ธฐ๋ฅ์ ์ ์ฌํ๊ฒ ์ง์ํ๋ค.
- ๋ฐ์ดํฐ๋ฒ ์ด์ค ๋ฐฉ์ธ๋ง ๋ณ๊ฒฝํ๋ฉด JPQL์ ์์ ํ์ง ์์๋ ์์ฐ์ค๋ฝ๊ฒ ๋ฐ์ดํฐ๋ฒ ์ด์ค๋ฅผ ๋ณ๊ฒฝํ ์ ์๋ค.
- SQL๋ณด๋ค ๊ฐ๊ฒฐํ๋ค. ์ํฐํฐ ์ง์ ์กฐํ, ๋ฌต์์ ์กฐ์ธ, ๋คํ์ฑ ์ง์์ผ๋ก ์ฝ๋๊ฐ ๊ฐ๊ฒฐํ๋ค.
//์ฟผ๋ฆฌ ์์ฑ
String jpql = "select m from Member as m where m.username = 'kim'";
List<Member> resultList = em.createQuery(jpql, Member.class).getResultList();
โฐ Criteria ์ฟผ๋ฆฌ ์๊ฐ
JPQL์ ์์ฑํ๋ ๋น๋ ํด๋์ค๋ค.
- ๋ฌธ์๊ฐ ์๋
query.select(m).where(...)์ฒ๋ผ ํ๋ก๊ทธ๋๋ฐ ์ฝ๋๋ก JPQL์ ์์ฑํ ์ ์๋ค๋ ์ฅ์ ์ด ์๋ค. - ์คํ๊ฐ ์์ด๋ ์ปดํ์ผ์ ์ฑ๊ณตํ๊ณ ์๋ฒ์ ๋ฐฐํฌํ ์ ์์ง๋ง, ํด๋น ์ฟผ๋ฆฌ๊ฐ ์คํ๋๋ ๋ฐํ์ ์์ ์ ์ค๋ฅ๊ฐ ๋ฐ์ํ๋ค.
- ์ปดํ์ผ ์์ ์ ์ค๋ฅ๋ฅผ ๋ฐ๊ฒฌํ ์ ์๋ค.
- IDE๋ฅผ ์ฌ์ฉํ๋ฉด ์ฝ๋ ์๋์์ฑ์ ์ง์ํ๋ค.
- ๋์ ์ฟผ๋ฆฌ๋ฅผ ์์ฑํ๊ธฐ ํธํ๋ค.
- ํ์ง๋ง ๋ณต์กํ๊ณ ์ฅํฉํ๋ค. ๋ฐ๋ผ์ ์ฌ์ฉํ๊ธฐ ๋ถํธํ ๋ฟ๋๋ฌ, ๊ฐ๋ ์ฑ ๋ํ ์ข์ง ์๋ค.
//Criteria ์ฌ์ฉ์ค๋น
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<Member> query = cb.createQuery(Member.class);
//๋ฃจํธ ํด๋์ค (์กฐํ๋ฅผ ์์ํ ํด๋์ค)
Root<Member> m = query.from(Member.class);
//์ฟผ๋ฆฌ ์์ฑ
CriteriaQuery<Member> cq = query.select(m).where(cb.equal(m.get("usernamen", "kim"));
List<Member> resultList = em.createQuery(cq).getResultList();
- ํ๋๋ช ์ ๋ฌธ์๋ก ์์ฑํ์ง ์๊ณ ์ฝ๋๋ก ์์ฑํ๊ณ ์ถ๋ค๋ฉด ๋ฉํ ๋ชจ๋ธ์ ์ฌ์ฉํ๋ฉด ๋๋ค.
โฐ QueryDSL ์๊ฐ
JPQL ๋น๋ ์ญํ ์ ํ๋ค.
- ์ฝ๋ ๊ธฐ๋ฐ์ด๋ฉด์ ๋จ์ํ๊ณ ์ฌ์ฉํ๊ธฐ ์ฝ๋ค.
- ์์ฑํ ์ฝ๋๋ JPQL๊ณผ ๋น์ทํด์ ๊ฐ๋ ์ฑ์ด ์ข๋ค.
JPA ํ์ค์ ์๋๊ณ , ์คํ์์ค ํ๋ก์ ํธ์ด๋ค.
//์ค๋น
JPAQuery query = new JPAQuery(em);
QMember member = QMember.member;
//์ฟผ๋ฆฌ, ๊ฒฐ๊ณผ์กฐํ
List<Member> members =
query.from(member)
.where(member.username.eq("kim"))
.list(member);
-
annotation ํ๋ก์ธ์๋ฅผ ์ฌ์ฉํด ์ฟผ๋ฆฌ ์ ์ฉ ํด๋์ค๋ฅผ ๋ง๋ค์ด์ผ ํ๋ค.
QMember๋Member์ํฐํฐ ํด๋์ค๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ์์ฑํ QueryDSL ์ฟผ๋ฆฌ ์ ์ฉ ํด๋์ค์ด๋ค.
โฐ ๋ค์ดํฐ๋ธ SQL ์๊ฐ
SQL์ ์ง์ ์ฌ์ฉํ ์ ์๋ ๊ธฐ๋ฅ์ด๋ค. ์๋์ ๊ฒฝ์ฐ์ ๋ํด ๋ค์ดํฐ๋ธ SQL์ ์ฌ์ฉํ ์ ์๋ค.
- JPQL์ ์ฌ์ฉํด๋ ํน์ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ์์กดํ๋ ๊ธฐ๋ฅ์ ์ฌ์ฉํด์ผ ํ ๋๊ฐ ์๋ค. (์ค๋ผํด ๋ฐ์ดํฐ๋ฒ ์ด์ค์
CONNECT BY, ํน์ ๋ฐ์ดํฐ๋ฒ ์ด์ค์์๋ง ๋์ํ๋ SQL ํํธ) - ๋ํ SQL์ ์ง์ํ์ง๋ง JPQL์ด ์ง์ํ์ง ์๋ ๊ธฐ๋ฅ์ ์ฌ์ฉํด์ผ ํ ๋๋ ์๋ค.
๋จ์ ์ผ๋ก๋ ํน์ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ์์กดํ๋ SQL์ ์์ฑํด์ผ ํ๋ค๋ ๊ฒ์ด๋ค.
- ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ๋ณ๊ฒฝ์ ๋ค์ดํฐ๋ธ SQL์ ์์ ์ ์๊ตฌํ๋ค.
String sql = "SELECT ID, AGE, TEAM_ID, NAME FROM MEMBER WHERE NAME = 'kim'";
List<Member> resultList = em.createNativeQuery(sql, Member.class).getResultList();
โฐ JDBC ์ง์ ์ฌ์ฉ, Mybatis ๊ฐ์ SQL ๋งคํผ ํ๋ ์์ํฌ ์ฌ์ฉ
JDBC ์ปค๋ฅ์ ์ ์ง์ ์ ๊ทผํ๊ณ ์ถ์ผ๋ฉด JPA๋ JDBC ์ปค๋ฅ์ ์ ํ๋ํ๋ API๋ฅผ ์ ๊ณตํ์ง ์์ผ๋ฏ๋ก JPA ๊ตฌํ์ฒด๊ฐ ์ ๊ณตํ๋ ๋ฐฉ๋ฒ์ ์ฌ์ฉํด์ผ ํ๋ค.
Session session = entityManager.unwrap(Session.class);
session.doWork(new Work() {
@Override
public void execute(Connection connection) throws SQLException {
// work...
}
});
- ๋จผ์ Hibernate
Session์ ๊ตฌํ๊ณ ,Session์doWork()๋ฉ์๋๋ฅผ ํธ์ถํ๋ฉด ๋๋ค. -
JDBC๋ ๋ง์ด๋ฐํฐ์ค๋ฅผ JPA์ ํจ๊ป ์ฌ์ฉํ๋ฉด ์์์ฑ ์ปจํ ์คํธ๋ฅผ ์ ์ ํ ์์ ์ ๊ฐ์ ๋ก ํ๋ฌ์ํด์ผ ํ๋ค.
- JDBC๋ฅผ ์ง์ ์ฌ์ฉํ๋ , SQL ๋งคํผ์ ์ฌ์ฉํ๋ ๋ชจ๋ JPA๋ฅผ ์ฐํํด์ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ์ ๊ทผํ๋๋ฐ, ๋ฌธ์ ๋ JPA๋ฅผ ์ฐํํ๋ SQL์ ๋ํด์๋ JPA๊ฐ ์ ํ ์ธ์ํ์ง ๋ชปํ๋ค๋ ๊ฒ์ด๋ค.
- ์ต์ ์ ๊ฒฝ์ฐ, ์์์ฑ ์ปจํ ์คํธ์ ๋ฐ์ดํฐ๋ฒ ์ด์ค๋ฅผ ๋ถ์ผ์น ์ํ๋ก ๋ง๋ค์ด ๋ฐ์ดํฐ ๋ฌด๊ฒฐ์ฑ์ ํผ์ํ ์๋ ์๋ค.
JPA๋ฅผ ์ฐํํด์ SQL์ ์คํํ๊ธฐ ์ง์ ์ ์์์ฑ ์ปจํ ์คํธ๋ฅผ ์๋์ผ๋ก ํ๋ฌ์ํด์ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ์์์ฑ ์ปจํ ์คํธ๋ฅผ ๋๊ธฐํํ๋ฉด ์ด๋ฌํ ์ด์๋ฅผ ํด๊ฒฐํ ์ ์๋ค.
๐ซ JPQL
JPQL์ ํน์ง์ด๋ค.
- JPQL์ ๊ฐ์ฒด์งํฅ ์ฟผ๋ฆฌ ์ธ์ด์ด๋ค. ๋ฐ๋ผ์ ํ ์ด๋ธ์ ๋์์ผ๋ก ์ฟผ๋ฆฌํ๋ ๊ฒ์ด ์๋๋ผ ์ํฐํฐ ๊ฐ์ฒด๋ฅผ ๋์์ผ๋ก ์ฟผ๋ฆฌํ๋ค.
- JPQL์ SQL์ ์ถ์ํํด์ ํน์ ๋ฐ์ดํฐ๋ฒ ์ด์ค SQL์ ์์กดํ์ง ์๋๋ค.
- JPQL์ ๊ฒฐ๊ตญ SQL๋ก ๋ณํ๋๋ค.
โฐ ๊ธฐ๋ณธ ๋ฌธ๋ฒ๊ณผ ์ฟผ๋ฆฌ API
JPQL๋ SQL๊ณผ ๋น์ทํ๊ฒ SELECT, UPDATE, DELETE ๋ฌธ์ ์ฌ์ฉํ ์ ์๋ค. (์ํฐํฐ๋ฅผ ์ ์ฅํ ๋๋ em.persist()๋ฅผ ์ฌ์ฉํ๋ฉด ๋๋ฏ๋ก INSERT๋ฌธ์ ์๋ค.)
- ์ ์ฒด ๊ตฌ์กฐ๋ SQL๊ณผ ๋น์ทํ๋ค.
SELECT ๋ฌธ
SELECT m FROM Member AS m where m.username = 'Hello'
- ๋์๋ฌธ์ ๊ตฌ๋ถ : ์ํฐํฐ์ ์์ฑ์ ๋์๋ฌธ์๋ฅผ ๊ตฌ๋ถํ๋ค. ํ์ง๋ง JPQL ํค์๋๋ ๋์๋ฌธ์๋ฅผ ๊ตฌ๋ถํ์ง ์๋๋ค.
- ์ํฐํฐ ์ด๋ฆ : JPQL์์ ์ฌ์ฉํ๋ ๊ฐ์ฒด๋ ํด๋์ค ๋ช
์ด ์๋๋ผ ์ํฐํฐ ๋ช
์ด๊ณ
@Entity(name=โXXXโ)๋ก ์ง์ ํ ์ ์๋ค. ์ง์ ํ์ง ์์ผ๋ฉด ํด๋์ค ๋ช ์ ๊ธฐ๋ณธ๊ฐ์ผ๋ก ์ฌ์ฉํ๋ค. - ๋ณ์นญ์ ํ์ : JPQL์ ๋ณ์นญ์ ํ์๋ก ์ฌ์ฉํด์ผ ํ๋ค. ๋ณ์นญ ์์ด ์์ฑํ๋ฉด ์๋ชป๋ ๋ฌธ๋ฒ์ด๋ผ๋ ์ค๋ฅ๊ฐ ๋ฐ์ํ๋ค.
TypeQuery, Query
์์ฑํ JPQL์ ์คํํ๋ ค๋ฉด ์ฟผ๋ฆฌ ๊ฐ์ฒด๋ฅผ ๋ง๋ค์ด์ผ ํ๋ค. ์ฟผ๋ฆฌ ๊ฐ์ฒด์๋ TypeQuery ์ Query ๊ฐ ์๊ณ ๋ฐํ ํ์
์ง์ ์ ๋ฐ๋ผ ๋๋๋ค.
- ๋ฐํํ ํ์
์ ๋ช
ํํ๊ฒ ์ง์ ํ ์ ์์ผ๋ฉด
TypeQuery๊ฐ์ฒด๋ฅผ ์ฌ์ฉํ๋ค. - ๋ฐํ ํ์
์ ๋ช
ํํ๊ฒ ์ง์ ํ ์ ์์ผ๋ฉด
Query๊ฐ์ฒด๋ฅผ ์ฌ์ฉํ๋ค.
TypedQuery<Member> query = em.createQuery("SELECT m FROM Member m", Member.class);
List<Member> resultList = query.getResultList();
for (Member member : resultList) {
System.out.println("member = " + member);
}
em.createQuery()์ ๋ ๋ฒ์งธ ํ๋ผ๋ฏธํฐ์ ๋ฐํํ ํ์ ์ ์ง์ ํ๋ฉดTypeQuery๋ฅผ ๋ฐํํ๊ณ ์ง์ ํ์ง ์์ผ๋ฉดQuery๋ฅผ ๋ฐํํ๋ค.- ์ด๋๋ ์กฐํ ๋์์ด
Member์ํฐํฐ์ด๋ฏ๋ก ์กฐํ ๋์ ํ์ ์ด ๋ช ํํดTypeQuery๋ฅผ ์ฌ์ฉํ ์ ์๋ค. ๋ช ํํ์ง ์๋ค๋ฉดQuery๋ก ๋ณ๊ฒฝํ๋ฉด ๋๋ค.
Query ๊ฐ์ฒด๋ SELECT ์ ์ ์กฐํ ๋์์ด ๋ ์ด์์ด๋ฉด Object[] ๋ฅผ ๋ฐํํ๊ณ , ์กฐํ ๋์์ด ํ๋๋ฉด Object ๋ฅผ ๋ฐํํ๋ค. ํ์
์ ๋ณํํ ํ์๊ฐ ์๋ TypeQuery ๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด ๋ ํธ๋ฆฌํ๋ค.
๊ฒฐ๊ณผ ์กฐํ
๋ค์ ๋ฉ์๋๋ค์ ํธ์ถํ๋ฉด ์ค์ ์ฟผ๋ฆฌ๋ฅผ ์คํํด์ ๋ฐ์ดํฐ๋ฒ ์ด์ค๋ฅผ ์กฐํํ๋ค.
query.getResultList(): ๊ฒฐ๊ณผ๋ฅผ ์์ ๋ก ๋ฐํํ๋ค. ๊ฒฐ๊ณผ๊ฐ ์์ผ๋ฉด ๋น ์ปฌ๋ ์ ์ ๋ฐํํ๋ค.-
query.getSingleResult(): ๊ฒฐ๊ณผ๊ฐ ์ ํํ ํ๋์ผ ๋ ์ฌ์ฉํ๋ค.- ๊ฒฐ๊ณผ๊ฐ ์์ผ๋ฉด
NoResultException๋ฐ์ํ๋ค. - 1๊ฐ๋ณด๋ค ๋ง์ผ๋ฉด
NonUniqueResultException๋ฐ์ํ๋ค.
- ๊ฒฐ๊ณผ๊ฐ ์์ผ๋ฉด
โฐ ํ๋ผ๋ฏธํฐ ๋ฐ์ธ๋ฉ
JDBC๋ ์์น ๊ธฐ์ค ํ๋ผ๋ฏธํฐ ๋ฐ์ธ๋ฉ๋ง ์ง์ํ์ง๋ง JPQL์ ์ด๋ฆ ๊ธฐ์ค ํ๋ผ๋ฏธํฐ ๋ฐ์ธ๋ฉ๋ ์ง์ํ๋ค.
์ด๋ฆ ๊ธฐ์ค ํ๋ผ๋ฏธํฐ
ํ๋ผ๋ฏธํฐ๋ฅผ ์ด๋ฆ์ผ๋ก ๊ตฌ๋ถํ๋ ๋ฐฉ๋ฒ์ผ๋ก, ์์ : ๋ฅผ ์ฌ์ฉ
String usernameParam = "User1";
TypedQuery<Member> query = em.createQuery("SELECT m FROM Member m where m.username = :username", Member.class);
query.setParameter("username", usernameParam);
List<Member> resultList = query.getResultList();
์ฐธ๊ณ ๋ก JPQL API๋ ๋๋ถ๋ถ ๋ฉ์๋ ์ฒด์ธ ๋ฐฉ์์ผ๋ก ์ค๊ณ๋์ด ์ฐ์ํ์ฌ ์์ฑ์ด ๊ฐ๋ฅํ๋ค.
์์น ๊ธฐ์ค ํ๋ผ๋ฏธํฐ
? ๋ค์์ ์์น ๊ฐ์ ์ฃผ์ด ์ฌ์ฉํ๋ค.
String usernameParam = "User1";
query.setParameter("username", usernameParam);
List<Member> resultList =
em.createQuery("SELECT m FROM Member m where m.username = ?1", Member.class)
.setParameter(1, usernameParam)
.getResultList();
- ์์น ๊ธฐ์ค ํ๋ผ๋ฏธํฐ ๋ฐฉ์๋ณด๋ค๋ ์ด๋ฆ ๊ธฐ์ค ํ๋ผ๋ฏธํฐ ๋ฐ์ธ๋ฉ ๋ฐฉ์์ ์ฌ์ฉํ๋ ๊ฒ์ด ๋ ๋ช ํํ๋ค.
ํ๋ผ๋ฏธํฐ ๋ฐ์ธ๋ฉ ๋ฐฉ์์ ์ ํ์ด ์๋ ํ์์ด๋ค.
โฐ ํ๋ก์ ์
SELECT ์ ์ ์กฐํํ ๋์์ ์ง์ ํ๋ ๊ฒ์ด๋ค. ํ๋ก์ ์ ๋์์๋ ์ํฐํฐ, ์๋ฒ ๋๋ ํ์ , ์ค์นผ๋ผ ํ์ (์ซ์, ๋ฌธ์ ๋ฑ ๊ธฐ๋ณธ ๋ฐ์ดํฐ ํ์ )์ด ์๋ค.
์ํฐํฐ ํ๋ก์ ์
SELECT m FROM Member m // ํ์
SELECT m.team FROM Member m // ํ
- ์ฝ๊ฒ ์๊ฐํ๋ฉด, ์ํ๋ ๊ฐ์ฒด๋ฅผ ๋ฐ๋ก ์กฐํํ ๊ฒ์ด๋ค.
- ์ปฌ๋ผ์ ํ๋ํ๋ ๋์ดํด์ ์กฐํํด์ผํ๋ SQL๊ณผ๋ ์ฐจ์ด๊ฐ ์๋ค.
- ์กฐํํ ์ํฐํฐ๋ ์์์ฑ ์ปจํ ์คํธ์์ ๊ด๋ฆฌ๋๋ค.
์๋ฒ ๋๋ ํ์
ํ๋ก์ ์
- JPQL์์ ์๋ฒ ๋๋ ํ์ ์ ์ํฐํฐ์ ๊ฑฐ์ ๋น์ทํ๊ฒ ์ฌ์ฉ๋๋ค. ์๋ฒ ๋๋ ํ์ ์ ์กฐํ์ ์์์ ์ด ๋ ์ ์๋ค๋ ์ ์ฝ์ด ์๋ค.
์๋ฒ ๋๋ ํ์ ์ ์ํฐํฐ ํ์ ์ด ์๋ ๊ฐ ํ์ ์ด๊ธฐ ๋๋ฌธ์ ์ง์ ์กฐํํ ์๋ฒ ๋๋ ํ์ ์ ์์์ฑ ์ปจํ ์คํธ์์ ๊ด๋ฆฌ๋์ง ์๋๋ค.
์ค์นผ๋ผ ํ์
ํ๋ก์ ์
์ซ์, ๋ฌธ์, ๋ ์ง์ ๊ฐ์ ๊ธฐ๋ณธ ๋ฐ์ดํฐ ํ์
๋ค์ ์ค์นผ๋ผ ํ์
์ด๋ผ ํ๋ค.
- ํต๊ณ ์ฟผ๋ฆฌ๋ ์ฃผ๋ก ์ค์นผ๋ผ ํ์ ์ผ๋ก ์กฐํํ๋ค.
์ฌ๋ฌ ๊ฐ ์กฐํ
์ํฐํฐ๋ฅผ ๋์์ผ๋ก ์กฐํํ๋ฉด ํธ๋ฆฌํ๊ฒ ์ง๋ง, ๊ผญ ํ์ํ ๋ฐ์ดํฐ๋ค๋ง ์ ํํด์ ์กฐํํด์ผ ํ ๋๋ ์๋ค.
- ์ด๋๋ ํ๋ก์ ์
์
Query๋ฅผ ์ฌ์ฉํ๋ค. - ์ญ์๋ ์กฐํํ ์ํฐํฐ๋ ์์์ฑ ์ปจํ ์คํธ์์ ๊ด๋ฆฌ๋๋ค.
NEW ๋ช
๋ น์ด
- ์ค์ ์ ํ๋ฆฌ์ผ์ด์
๊ฐ๋ฐ์์๋
Object[]๋ฅผ ์ง์ ์ฌ์ฉํ์ง ์๊ณ ์๋ฏธ์๋ ๊ฐ์ฒด๋ก ๋ณํํด์ ์ฌ์ฉํ๋ค. - SELECT ๋ค์์
NEW๋ช ๋ น์ด๋ฅผ ์ฌ์ฉํด ๋ฐํ๋ฐ์ ํด๋์ค๋ฅผ ์ง์ ํ ์ ์๋ค. ํด๋์ค์ ์์ฑ์์ JPQL ์กฐํ ๊ฒฐ๊ณผ๋ฅผ ๋๊ฒจ์ค ์ ์๋ค.
NEW ๋ช
๋ น์ด ์ฌ์ฉ ์ ๋ค์๊ณผ ๊ฐ์ ์ฃผ์์ฌํญ์ด ์๋ค.
- ํจํค์ง ๋ช ์ ํฌํจํ ์ ์ฒด ํด๋์ค๋ช ์ ์ ๋ ฅํด์ผ ํ๋ค.
- ์์์ ํ์ ์ด ์ผ์นํ๋ ์์ฑ์๊ฐ ํ์ํ๋ค.
โฐ ํ์ด์ง API
ํ์ด์ง ์ฒ๋ฆฌ์ฉ SQL์ ์์ฑํ๋ ์ผ์ ์ง๋ฃจํ๊ณ ๋ฐ๋ณต์ ์ด๋ค. ๋ ํฐ ๋ฌธ์ ๋ ๋ฐ์ดํฐ๋ฒ ์ด์ค๋ง๋ค ํ์ด์ง์ ์ฒ๋ฆฌํ๋ SQL ๋ฌธ๋ฒ์ด ๋ค๋ฅด๋ค๋ ๊ฒ์ด๋ค.
JPA๋ ํ์ด์ง์ ๋ค์ ๋ API๋ก ์ถ์ํํ๋ค.
setFirstResult(int startPosition): ์กฐํ ์์ ์์น(0๋ถํฐ ์์ํ๋ค)setMaxResults(int maxResult): ์กฐํํ ๋ฐ์ดํฐ ์
TypedQuery<Member> query =
em.createQuery("SELECT m FROM Member m ORDER BY m.username DESC", Member.class);
query.setFirstResult(10);
query.setMaxResults(20);
query.getResultList();
setFirstResult(10)์ผ๋ก, 11๋ฒ์งธ๋ถํฐ ์์ํด์ ์ด 20๊ฑด(setMaxResults(20))์ ๋ฐ์ดํฐ๋ฅผ ์กฐํํ๋ค.
๋ฐ์ดํฐ๋ฒ ์ด์ค๋ง๋ค ๋ค๋ฅธ ํ์ด์ง ์ฒ๋ฆฌ๋ฅผ ๊ฐ์ API๋ก ์ฒ๋ฆฌํ ์ ์๋ ๊ฒ์ ์ด์ ์ ๋ค๋ฃฌ ๋ฐ์ดํฐ๋ฒ ์ด์ค ๋ฐฉ์ธ ๋๋ถ์ด๋ค.
โฐ ์งํฉ๊ณผ ์ ๋ ฌ
์งํฉ์ ์งํฉ ํจ์์ ํจ๊ป ํต๊ณ ์ ๋ณด๋ฅผ ๊ตฌํ ๋ ์ฌ์ฉํ๋ค.
์งํฉ ํจ์
|ํจ์|์ค๋ช
|
|:---:|:---:|
|COUNT|๊ฒฐ๊ณผ ์๋ฅผ ๊ตฌํ๋ค. ๋ฐํ ํ์
: Long|
|MAX, MIN|์ต๋, ์ต์ ๊ฐ์ ๊ตฌํ๋ค. ๋ฌธ์, ์ซ์, ๋ ์ง ๋ฑ์ ์ฌ์ฉํ๋ค.|
|AVG|ํ๊ท ๊ฐ์ ๊ตฌํ๋ค. ์ซ์ํ์
๋ง ์ฌ์ฉํ ์ ์๋ค. ๋ฐํ ํ์
: Double|
|SUM|ํฉ์ ๊ตฌํ๋ค. ์ซ์ํ์
๋ง ์ฌ์ฉํ ์ ์๋ค. ๋ฐํ ํ์
: ์ ์ํฉ Long, ์์ํฉ: Double, BigInteger ํฉ: BigInteger, BigDecimal ํฉ: BigDecimal|
์ฐธ๊ณ ์ฌํญ
NULL๊ฐ์ ๋ฌด์ํ๋ฏ๋ก ํต๊ณ์ ์กํ์ง ์๋๋ค.- ๋ง์ฝ ๊ฐ์ด ์๋๋ฐ ์งํฉ ํจ์๋ฅผ ์ฌ์ฉํ๋ฉด
NULL๊ฐ์ด ๋๋ค. ๋จCOUNT๋ 0์ด ๋๋ค. DISTINCT๋ฅผ ์งํฉ ํจ์ ์์ ์ฌ์ฉํด์ ์ค๋ณต๋ ๊ฐ์ ์ ๊ฑฐํ๊ณ ๋์ ์งํฉ์ ๊ตฌํ ์ ์๋ค.DISTINCT๋ฅผCOUNT์์ ์ฌ์ฉํ ๋ ์๋ฒ ๋๋ ํ์ ์ ์ง์ํ์ง ์๋๋ค.
GROUP BY, HAVING
GROUP BY๋ ํต๊ณ ๋ฐ์ดํฐ๋ฅผ ๊ตฌํ ๋ ํน์ ๊ทธ๋ฃน๋ผ๋ฆฌ ๋ฌถ์ด์ค๋ค.HAVING์ ๊ทธ๋ฃนํํ ํต๊ณ ๋ฐ์ดํฐ๋ฅผ ๊ธฐ์ค์ผ๋ก ํํฐ๋งํ๋ค.
โฐ JPQL ์กฐ์ธ
SQL ์กฐ์ธ๊ณผ ๊ธฐ๋ฅ์ ๊ฐ๊ณ ๋ฌธ๋ฒ๋ง ์ฝ๊ฐ ๋ค๋ฅด๋ค.
๋ด๋ถ ์กฐ์ธ
INNER JOIN ์ ์ฌ์ฉํ๋ค. ์ฌ๊ธฐ์ INNER ๋ ์๋ต ๊ฐ๋ฅํ๋ค.
SELECT m FROM Member m INNER JOIN m.team t WHERE t.name = :teamName
JPQL ๋ด๋ถ ์กฐ์ธ ๊ตฌ๋ฌธ์ ๋ณด๋ฉด, SQL์ ์กฐ์ธ๊ณผ ์ฝ๊ฐ ๋ค๋ฅด๋ค. JPQL์ ๊ฐ์ฅ ํฐ ํน์ง์ ์ฐ๊ด ํ๋๋ฅผ ์ฌ์ฉํ๋ค๋ ๊ฒ์ด๋ค. ์ด๋ ๋ค๋ฅธ ์ํฐํฐ์ ์ฐ๊ด๊ด๊ณ๋ฅผ ๊ฐ์ง๊ธฐ ์ํด ์ฌ์ฉํ๋ ํ๋์ด๋ค.
FROM Member m: ํ์์ ์ ํํ๊ณm์ด๋ผ๋ ๋ณ์นญ์ ์ฃผ์๋ค.Member m JOIN m.team t: ํ์์ด ๊ฐ์ง๊ณ ์๋ ์ฐ๊ด ํ๋๋ก ํ๊ณผ ์กฐ์ธํ๋ค.
์ธ๋ถ ์กฐ์ธ
SELECT m FROM Member m LEFT [OUTER] JOIN m.team t
- ๊ธฐ๋ฅ์ SQL์ ์ธ๋ถ ์กฐ์ธ๊ณผ ๊ฐ๋ค.
OUTER๋ ์๋ต ๊ฐ๋ฅํด์ ๋ณดํตLEFT JOIN์ผ๋ก ๋ง์ด ์ฌ์ฉํ๋ค.
์ปฌ๋ ์
์กฐ์ธ
์ผ๋๋ค ๊ด๊ณ๋ ๋ค๋๋ค ๊ด๊ณ์ฒ๋ผ ์ปฌ๋ ์
์ ์ฌ์ฉํ๋ ๊ณณ์ ์กฐ์ธํ๋ ๊ฒ์ด๋ค.
- [ํ์ -> ํ] ์ผ๋ก์ ์กฐ์ธ์ ๋ค๋์ผ ์กฐ์ธ์ด๋ฉด์ ๋จ์ผ ๊ฐ ์ฐ๊ด ํ๋(
m.team)๋ฅผ ์ฌ์ฉํ๋ค. - [ํ -> ํ์] ์ผ๋ก์ ์กฐ์ธ์ ๋ฐ๋๋ก ์ผ๋๋ค ์กฐ์ธ์ด๋ฉด์ ์ปฌ๋ ์
๊ฐ ์ฐ๊ด ํ๋(
m.members)๋ฅผ ์ฌ์ฉํ๋ค.
์ธํ ์กฐ์ธ
WHERE ์ ์ ์ฌ์ฉํด์ ์ธํ ์กฐ์ธ์ ์ฌ์ฉํ ์ ์๋ค. ์ด๋ ๋ด๋ถ ์กฐ์ธ๋ง ์ง์ํ๋ ์กฐ์ธ์ด๋ค.
- ์ ํ ๊ด๊ณ์๋ ์ํฐํฐ๋ ์กฐ์ธํ ์ ์๋ค.
JOIN ON ์
ON ์ ์ ์ฌ์ฉํ๋ฉด ์กฐ์ธ ๋์์ ํํฐ๋งํ๊ณ ์กฐ์ธํ ์ ์๋ค.
- ๋ด๋ถ ์กฐ์ธ์
ON์ ์WHERE์ ์ ์ฌ์ฉํ๋ ๊ฒ๊ณผ ๊ฒฐ๊ณผ๊ฐ ๊ฐ์, ๋ณดํตON์ ์ ์ธ๋ถ ์กฐ์ธ์์๋ง ์ฌ์ฉํ๋ค.
โฐ ํ์น ์กฐ์ธ
SQL์์ ๋ค๋ฃจ๋ ์กฐ์ธ์ ์ข ๋ฅ๋ ์๋์ง๋ง JPQL์์ ์ฑ๋ฅ ์ต์ ํ๋ฅผ ์ํด ์ ๊ณตํ๋ ๊ธฐ๋ฅ์ด๋ค.
- ์ฐ๊ด๋ ์ํฐํฐ๋ ์ปฌ๋ ์
์ ํ ๋ฒ์ ๊ฐ์ด ์กฐํํ๋ ๊ธฐ๋ฅ์ผ๋ก,
join fetch๋ช ๋ น์ด๋ก ์ฌ์ฉํ ์ ์๋ค.
ํ์น ์กฐ์ธ ::= [ LEFT [OUTER] | INNER ] JOIN FETCH ์กฐ์ธ๊ฒฝ๋ก
์ํฐํฐ ํ์น ์กฐ์ธ
์ฐ๊ด๋ ์ํฐํฐ๋ ์ปฌ๋ ์
์ ํจ๊ป ์กฐํํ๋ค.
- ๋ณ์นญ์ ์ฌ์ฉํ ์ ์๋ค.
Hibernate๋ ๋ณ์นญ์ ํ์ฉํ๋ค.
String jpql = "select m from Member m join fetch m.team";
List<Member> members = em.createQuery(jpql, Member.class).getResultList();
for (Member member : members) {
//ํ์น ์กฐ์ธ์ผ๋ก ํ์๊ณผ ํ์ ํจ๊ป ์กฐํํด์ ์ง์ฐ ๋ก๋ฉ ๋ฐ์ ์ ํจ
Systern.out.printin("username = " + member.getUsername () + ", " +
"teamname = " + member.getTeam().name());
}
-
ํ์๊ณผ ํ์ ์ง์ฐ ๋ก๋ฉ์ผ๋ก ์ค์ ํ๋ค๊ณ ๊ฐ์ ํ๋ฉด,
- ํ์ ์กฐํ ์ ํ์น ์กฐ์ธ์ ์ฌ์ฉํด ํ๋ ํจ๊ป ์กฐํํ์ผ๋ฏ๋ก ์ฐ๊ด๋ ํ ์ํฐํฐ๋ ํ๋ก์๊ฐ ์๋ ์ค์ ์ํฐํฐ๋ค.
- ์ฆ, ์ง์ฐ ๋ก๋ฉ์ด ๋ฐ์ํ์ง ์๋๋ค.
์ปฌ๋ ์
ํ์น ์กฐ์ธ
์ผ๋๋ค ๊ด๊ณ์ธ ์ปฌ๋ ์
์ ํ์น ์กฐ์ธํ๋ค.
- ํ(์ผ)์ ์กฐํํ๋ฉด์ ํ์น ์กฐ์ธ์ ์ฌ์ฉํด ์ฐ๊ด๋ ํ์ ์ปฌ๋ ์ (๋ค)๋ ํจ๊ป ์กฐํํ๋ค.
์ผ๋๋ค ์กฐ์ธ์ ๊ฒฐ๊ณผ๊ฐ ์ฆ๊ฐํ ์ ์์ง๋ง ์ผ๋์ผ, ๋ค๋์ผ ์กฐ์ธ์ ๊ฒฐ๊ณผ๋ ์ฆ๊ฐํ์ง ์๋๋ค.
String jpql = "select t from Team t join fetch t.members where t.name = 'ํA'";
List<Member> teams = em.createQuery(jpql, Team.class).getResultList();
for (Team team : teams) {
System.out.println("teamname = " + team.getName() + ", team = " + team);
for (Member member : team.getMembers()) {
//ํ์น ์กฐ์ธ์ผ๋ก ํ๊ณผ ํ์์ ํจ๊ป ์กฐํํด์ ์ง์ฐ ๋ก๋ฉ ๋ฐ์ ์ ํจ
Systern.out.printin("->username = " + member.getUsername () + ", member = " + member);
}
}
ํ์น ์กฐ์ธ๊ณผ DISTINCT
- SQL์
DISTINCT๋ ์ค๋ณต๋ ๊ฒฐ๊ณผ๋ฅผ ์ ๊ฑฐํ๋ ๋ช ๋ น์ด์ด๋ค. - JPQL์
DISTINCT๋ช ๋ น์ด๋ SQL์DISTINCT๋ฅผ ์ถ๊ฐํ๋ ๊ฒ์ ๋ฌผ๋ก ์ด๊ณ ์ ํ๋ฆฌ์ผ์ด์ ์์ ํ ๋ฒ ๋ ์ค๋ณต์ ์ ๊ฑฐํ๋ค.
ํ์น ์กฐ์ธ๊ณผ ์ผ๋ฐ ์กฐ์ธ์ ์ฐจ์ด
// ๋ด๋ถ ์กฐ์ธ JPQL
select t
from Team t join t.members m
where t.name = 'ํA'
-- ์คํ๋ SQL
SELECT T.*
FROM TEAM TINNER JOIN MEMBER M
ON T.ID=M.TEAM_ID
WHERE T.NAME = 'ํA*'
JPQL์ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํํ ๋ ์ฐ๊ด๊ด๊ณ๊น์ง ๊ณ ๋ คํ์ง ์๋๋ค. ๋จ์ง SELECT ์ ์ ์ง์ ํ ์ํฐํฐ๋ง ์กฐํํ ๋ฟ์ด๋ค.
- ๋ฐ๋ผ์, ํ๊ณผ ํ์ ์ปฌ๋ ์ ์ ์ผ๋ฐ ์กฐ์ธํ๋ฉด ํ ์ํฐํฐ๋ง ์กฐํํ๊ณ ์ฐ๊ด๋ ํ์ ์ปฌ๋ ์ ์ ์กฐํํ์ง ์๋๋ค.
- ๋ฐ๋ฉด ํ์น ์กฐ์ธ์ ์ฌ์ฉํ๋ฉด ์ฐ๊ด๋ ์ํฐํฐ๋ ํจ๊ป ์กฐํํ๋ค.
ํ์น ์กฐ์ธ์ ํน์ง
ํ์น ์กฐ์ธ์ ์ฌ์ฉํ๋ฉด SQL ํ ๋ฒ์ผ๋ก ์ฐ๊ด๋ ์ํฐํฐ๋ค์ ํจ๊ป ์กฐํํ ์ ์์ด์ SQL ํธ์ถ ํ์๋ฅผ ์ค์ฌ ์ฑ๋ฅ์ ์ต์ ํํ ์ ์๋ค.
๋ค์์ฒ๋ผ ์ํฐํฐ์ ์ง์ ์ ์ฉํ๋ ๋ก๋ฉ ์ ๋ต์ ์ ํ๋ฆฌ์ผ์ด์ ์ ์ฒด์ ์ํฅ์ ๋ฏธ์น๋ฏ๋ก ๊ธ๋ก๋ฒ ๋ก๋ฉ ์ ๋ต์ด๋ผ๊ณ ํ๋ค.
@OneToMany(fetch = FetchType.LAZY)- ํ์น ์กฐ์ธ์ ๊ธ๋ก๋ฒ ๋ก๋ฉ ์ ๋ต๋ณด๋ค ์ฐ์ ํ๋ค. ์ฆ, ์ง์ฐ ๋ก๋ฉ์ ๊ธ๋ก๋ฒ๋ก ์ค์ ํด๋ JPQL์์ ํ์น ์กฐ์ธ์ ์ฌ์ฉํ๋ฉด ํ์น ์กฐ์ธ์ ์ ์ฉํ๋ค.
- ๊ธ๋ก๋ฒ ๋ก๋ฉ ์ ๋ต์ ์ง์ฐ ๋ก๋ฉ์ ์ฌ์ฉํ๊ณ ์ต์ ํ๊ฐ ํ์ํ๋ฉด ํ์น ์กฐ์ธ์ ์ ์ฉํ๋ ๊ฒ์ด ์ฑ๋ฅ๋ฉด์์ ํจ๊ณผ์ ์ด๋ค.
๋ํ, ํ์น ์กฐ์ธ์ ์ฌ์ฉํ๋ฉด ์ฐ๊ด๋ ์ํฐํฐ๋ฅผ ์ฟผ๋ฆฌ ์์ ์ ์กฐํํ๋ฏ๋ก ์ง์ฐ ๋ก๋ฉ์ด ๋ฐ์ํ์ง ์๋๋ค.
- ์ฆ, ์ค์์ ์ํ์์๋ ๊ฐ์ฒด ๊ทธ๋ํ๋ฅผ ํ์ํ ์ ์๋ค.
ํ์น ์กฐ์ธ์ ํ๊ณ
-
ํ์น ์กฐ์ธ ๋์์๋ ๋ณ์นญ์ ์ค ์ ์๋ค.
- ๋ณ์นญ์ ์๋ชป ์ฌ์ฉํ๋ฉด ์ฐ๊ด๋ ๋ฐ์ดํฐ ์๊ฐ ๋ฌ๋ผ์ ธ์ ๋ฐ์ดํฐ ๋ฌด๊ฒฐ์ฑ์ด ๊นจ์ง ์ ์์ผ๋ฏ๋ก ์กฐ์ฌํด์ ์ฌ์ฉํด์ผ ํ๋ค.
- ํนํ 2์ฐจ ์บ์์ ํจ๊ป ์ฌ์ฉํ ๋ ์กฐ์ฌํด์ผ ํ๋๋ฐ, ์ฐ๊ด๋ ๋ฐ์ดํฐ ์๊ฐ ๋ฌ๋ผ์ง ์ํ์์ 2์ฐจ ์บ์์ ์ ์ฅ๋๋ฉด ๋ค๋ฅธ ๊ณณ์์ ์กฐํํ ๋๋ ์ฐ๊ด๋ ๋ฐ์ดํฐ ์๊ฐ ๋ฌ๋ผ์ง๋ ๋ฌธ์ ๊ฐ ๋ฐ์ํ ์ ์๋ค.
-
๋ ์ด์์ ์ปฌ๋ ์ ์ ํ์นํ ์ ์๋ค.
- ๊ตฌํ์ฒด์ ๋ฐ๋ผ ๋๊ธฐ๋ ํ๋๋ฐ ์ปฌ๋ ์ * ์ปฌ๋ ์ ์นดํ ์์ ๊ณฑ์ด ๋ง๋ค์ด ์ง๋ฏ๋ก ์ฃผ์ํด์ผ ํ๋ค.
-
์ปฌ๋ ์ ์ ํ์น ์กฐ์ธํ๋ฉด ํ์ด์ง API(
setFirstResult,setMaxResults)๋ฅผ ์ฌ์ฉํ ์ ์๋ค.- ํ์ด๋ฒ๋ค์ดํธ์์ ์ปฌ๋ ์ ์ ํ์น ์กฐ์ธํ๊ณ ํ์ด์ง API๋ฅผ ์ฌ์ฉํ๋ฉด ๊ฒฝ๊ณ ๋ก๊ทธ๋ฅผ ๋จ๊ธฐ๋ฉด์ ๋ฉ๋ชจ๋ฆฌ์์ ํ์ด์ง ์ฒ๋ฆฌ๋ฅผ ํ๋๋ฐ, ๋ฐ์ดํฐ๊ฐ ์ ์ผ๋ฉด ์๊ด์๊ฒ ์ง๋ง ๋ฐ์ดํฐ๊ฐ ๋ง์ผ๋ฉด ์ฑ๋ฅ ์ด์์ ๋ฉ๋ชจ๋ฆฌ ์ด๊ณผ ์์ธ๊ฐ ๋ฐ์ํ ์ ์์ด์ ์ํํ๋ค.
ํ์น ์กฐ์ธ์ ๊ฐ์ฒด ๊ทธ๋ํ๋ฅผ ์ ์งํ ๋ ์ฌ์ฉํ๋ฉด ํจ๊ณผ์ ์ด๋ค. ๋ฐ๋ฉด์ ์ฌ๋ฌ ํ ์ด๋ธ์ ์กฐ์ธํด์ ์ํฐํฐ๊ฐ ๊ฐ์ง ๋ชจ์์ด ์๋ ์ ํ ๋ค๋ฅธ ๊ฒฐ๊ณผ๋ฅผ ๋ด์ผ ํ๋ค๋ฉด ์ต์ง๋ก ํ์น ์กฐ์ธ์ ์ฌ์ฉํ๊ธฐ ๋ณด๋ค๋ ์ฌ๋ฌ ํ ์ด๋ธ์์ ํ์ํ ํ๋๋ค๋ง ์กฐํํด์ DTO๋ก ๋ฐํํ๋ ๊ฒ์ด ๋ ํจ๊ณผ์ ์ผ ์ ์๋ค.
โฐ ๊ฒฝ๋ก ํํ์
.(์ )์ ์ฐ์ด ๊ฐ์ฒด ๊ทธ๋ํ๋ฅผ ํ์ํ๋ ๊ฒ์ด๋ค.
select m.username -- ๊ฒฝ๋ก ํํ์
from Member m
join m.team t -- ๊ฒฝ๋ก ํํ์
join m.orders o -- ๊ฒฝ๋ก ํํ์
where t.name = 'ํA' -- ๊ฒฝ๋ก ํํ์
์ฉ์ด ์ ๋ฆฌ
- ์ํ ํ๋(state field) : ๋จ์ํ ๊ฐ์ ์ ์ฅํ๊ธฐ ์ํ ํ๋(ํ๋ ๋๋ ํ๋กํผํฐ)
-
์ฐ๊ด ํ๋(association field) : ์ฐ๊ด๊ด๊ณ๋ฅผ ์ํ ํ๋, ์๋ฒ ๋๋ ํ์ ํฌํจ(ํ๋ ๋๋ ํ๋กํผํฐ)
- ๋จ์ผ ๊ฐ ์ฐ๊ด ํ๋ :
@ManyToOne,@OneToOne, ๋์์ด ์ํฐํฐ - ์ปฌ๋ ์
๊ฐ ์ฐ๊ด ํ๋ :
@OneToMany,@ManyToMany, ๋์์ด ์ปฌ๋ ์
- ๋จ์ผ ๊ฐ ์ฐ๊ด ํ๋ :
@Entity
public class Member {
@Id @GeneratedValue
private Long id;
@Column(name="name")
private String username; // ์ํ ํ๋
private Integer age; // ์ํ ํ๋
@ManyToOne(..)
private Team team; // ์ฐ๊ด ํ๋(๋จ์ผ ๊ฐ ์ฐ๊ด ํ๋)
@OneToMany(..)
private List<Order> orders; // ์ฐ๊ด ํ๋(์ปฌ๋ ์
๊ฐ ์ฐ๊ด ํ๋)
...
}
- ์ํ ํ๋ :
t.username,t.age - ๋จ์ผ ๊ฐ ์ฐ๊ด ํ๋ :
m.team - ์ปฌ๋ ์
๊ฐ ์ฐ๊ด ํ๋ :
m.orders
๊ฒฝ๋ก ํํ์๊ณผ ํน์ง
๊ฒฝ๋ก ํํ์์ ์ฌ์ฉํด ๊ฒฝ๋ก ํ์์ ์ํด์๋ ๋ค์ 3๊ฐ์ง ๊ฒฝ๋ก์ ๋ฐ๋ผ ์ด๋ค ํน์ง์ด ์๋์ง ์์์ผ ํ๋ค.
- ์ํ ํ๋ ๊ฒฝ๋ก : ๊ฒฝ๋ก ํ์์ ๋์ด๋ค. ๋๋ ํ์ ๋ถ๊ฐ๋ฅํ๋ค.
- ๋จ์ผ ๊ฐ ์ฐ๊ด ๊ฒฝ๋ก : ๋ฌต์์ ์ผ๋ก ๋ด๋ถ ์กฐ์ธ์ด ์ผ์ด๋๋ค. ๋จ์ผ ๊ฐ ์ฐ๊ด ๊ฒฝ๋ก๋ ๊ณ์ ํ์ํ ์ ์๋ค.
- ์ปฌ๋ ์ ๊ฐ ์ฐ๊ด ๊ฒฝ๋ก : ๋ฌต์์ ์ผ๋ก ๋ด๋ถ ์กฐ์ธ์ด ์ผ์ด๋๋ค. ๋๋ ํ์ํ ์ ์๋ค. ๋จ FROM ์ ์์ ์กฐ์ธ์ ํตํด ๋ณ์นญ์ ์ป์ผ๋ฉด ๋ณ์นญ์ผ๋ก ํ์ํ ์ ์๋ค.
๋ช ์์ ์กฐ์ธ์
JOIN์ ์ง์ ๋ช ์ํ๋ ๊ฒ์ด๊ณ , ๋ฌต์์ ์กฐ์ธ์ ๊ฒฝ๋ก ํํ์์ ์ํด ๋ฌต์์ ์ผ๋ก ์กฐ์ธ์ด ์ผ์ด๋๋ ๊ฒ์ผ๋ก, ๋ด๋ถ ์กฐ์ธ(INNER JOIN)๋ง ํ ์ ์๋ค.
์ปฌ๋ ์
๊ฐ ์ฐ๊ด ๊ฒฝ๋ก ํ์
JPQL์ ๋ค๋ฃจ๋ฉด์ ๋ง์ด ํ๋ ์ค์ ์ค ํ๋๋ ์ปฌ๋ ์
๊ฐ์์ ๊ฒฝ๋ก ํ์์ ์๋ํ๋ ๊ฒ์ด๋ค.
select t.members from Team t -- ์ฑ๊ณต
select t.members.username from Team t -- ์คํจ
- ์ปฌ๋ ์ ๊น์ง๋ ๊ฒฝ๋ก ํ์์ด ๊ฐ๋ฅํ๋ค.
- ํ์ง๋ง ์ปฌ๋ ์ ์์ ๊ฒฝ๋ก ํ์์ ์์ํ๋ ๋ ๋ฒ์งธ ์๋ ํ๋ฝ๋์ง ์๋๋ค. ์ด๋ฅผ ์ํด์๋ ์กฐ์ธ์ ์ฌ์ฉํด ์๋ก์ด ๋ณ์นญ์ ํ๋ํด์ผ ํ๋ค.
๊ฒฝ๋ก ํ์์ ์ฌ์ฉํ ๋ฌต์์ ์กฐ์ธ ์ ์ฃผ์์ฌํญ
๊ฒฝ๋ก ํ์์ ์ฌ์ฉํ๋ฉด ๋ฌต์์ ์กฐ์ธ์ด ๋ฐ์ํด SQL์์ ๋ด๋ถ ์กฐ์ธ์ด ์ผ์ด๋ ์ ์๋ค. ์ด๋ ์ฃผ์์ฌํญ์ ๋ค์๊ณผ ๊ฐ๋ค.
- ํญ์ ๋ด๋ถ ์กฐ์ธ์ด๋ค.
- ์ปฌ๋ ์ ์ ๊ฒฝ๋ก ํ์์ ๋์ด๋ค. ์ปฌ๋ ์ ์์ ๊ฒฝ๋ก ํ์์ ํ๋ ค๋ฉด ๋ช ์์ ์ผ๋ก ์กฐ์ธํด์ ๋ณ์นญ์ ์ป์ด์ผ ํ๋ค.
- ๊ฒฝ๋ก ํ์์ ์ฃผ๋ก SELECT, WHERE ์ (๋ค๋ฅธ ๊ณณ์์๋ ์ฌ์ฉ๋จ)์์ ์ฌ์ฉํ์ง๋ง ๋ฌต์์ ์กฐ์ธ์ผ๋ก ์ธํด SQL์ FROM ์ ์ ์ํฅ์ ์ค๋ค.
์ฑ๋ฅ์ด ์ฃผ์ฉํ๋ฉด ๋ถ์ํ๊ธฐ ์ฝ๋๋ก ๋ฌต์์ ์กฐ์ธ๋ณด๋ค๋ ๋ช ์์ ์กฐ์ธ์ ์ฌ์ฉํ์.
โฐ ์๋ธ ์ฟผ๋ฆฌ
JPQL๋ SQL์ฒ๋ผ ์๋ธ ์ฟผ๋ฆฌ๋ฅผ ์ง์ํ๋ค. ๋ค์๊ณผ ๊ฐ์ ์ ์ฝ์ฌํญ์ด ์กด์ฌํ๋ค.
- ์๋ธ ์ฟผ๋ฆฌ๋ฅผ WHERE, HAVING ์ ์์๋ง ์ฌ์ฉํ ์ ์๊ณ ,
- SELECT, FROM ์ ์์๋ ์ฌ์ฉํ ์ ์๋ค.
Hibernate์ HQL์ SELECT ์ ์ ์๋ธ ์ฟผ๋ฆฌ๋ ํ์ฉํ๋ค.
select m from Member m where m.age > (select avg(m2.age) from Member m2)
- ํ๊ท ๋ณด๋ค ๋์ด๊ฐ ๋ง์ ํ์์ ์ฐพ๋๋ค.
์๋ธ ์ฟผ๋ฆฌ ํจ์
- [NOT] EXISTS (subquery)
- { ALL | ANY | SOME } (subquery)
- [NOT] IN (subquery)
EXISTS
- ์๋ธ ์ฟผ๋ฆฌ์ ๊ฒฐ๊ณผ๊ฐ ์กด์ฌํ๋ฉด ์ฐธ์ด๋ค. NOT์ ๋ฐ๋
{ ALL | ANY | SOME }
- ๋น๊ต ์ฐ์ฐ์์ ๊ฐ์ด ์ฌ์ฉํ๋ค.
- ALL: ์กฐ๊ฑด์ ๋ชจ๋ ๋ง์กฑํ๋ฉด ์ฐธ์ด๋ค.
- ANY ํน์ SOME: ๋์ ๊ฐ์ ์๋ฏธ์ด๋ค. ์กฐ๊ฑด์ ํ๋๋ผ๋ ๋ง์กฑํ๋ฉด ์ฐธ์ด๋ค.
IN
- ์๋ธ ์ฟผ๋ฆฌ์ ๊ฒฐ๊ณผ ์ค ํ๋๋ผ๋ ๊ฐ์ ๊ฒ์ด ์์ผ๋ฉด ์ฐธ์ด๋ค. ์๋ธ ์ฟผ๋ฆฌ๊ฐ ์๋ ๊ณณ์์๋ ์ฌ์ฉํ๋ค.
โฐ ์กฐ๊ฑด์
ํ์ ํํ JPQL์์ ์ฌ์ฉํ๋ ํ์ ์ ์๋์ ๊ฐ์ด ํ์ํ๊ณ , ๋์๋ฌธ์๋ ๊ตฌ๋ถํ์ง ์๋๋ค.
| ์ข ๋ฅ | ์ค๋ช | ์์ |
|---|---|---|
| ๋ฌธ์ | ์์ ๋ฐ์ดํ ์ฌ์ด์ ํํ | 'HELLO', 'She''s' |
| ์ซ์ | L(Long), D(Double), F(Float) | 10L, 10D, 10F |
| ๋ ์ง | Date{d 'yyyy-dd-dd'} TIME{t 'hh-mm-ss'} DATETIME{ts 'yyyy-dd-dd hh:mm:ss.f'} |
{d '2012-03-24'} |
| Boolean | TRUE, FALSE | |
| Enum | ํจํค์ง๋ช ์ ํฌํจํ ์ ์ฒด ์ด๋ฆ์ ์ฌ์ฉํด์ผ ํ๋ค. | jpabook.MemberType.Admin |
| ์ํฐํฐ ํ์ | ์ํฐํฐ์ ํ์ ์ ํํํ๋ค. ์ฃผ๋ก ์์๊ณผ ๊ด๋ จํด์ ์ฌ์ฉํ๋ค. | TYPE(m) = Member |
์ฐ์ฐ์ ์ฐ์ ์์
- ๊ฒฝ๋ก ํ์ ์ฐ์ฐ(.)
- ์ํ ์ฐ์ฐ
- ๋น๊ต ์ฐ์ฐ
- ๋ ผ๋ฆฌ ์ฐ์ฐ
์ปฌ๋ ์
์
์ปฌ๋ ์
์๋ง ์ฌ์ฉํ๋ ํน๋ณํ ๊ธฐ๋ฅ์ด๋ค. ์ปฌ๋ ์
์ ์ปฌ๋ ์
์ ์ด์ธ์ ๋ค๋ฅธ ์์ ์ฌ์ฉํ ์ ์๋ค.
-
๋น ์ปฌ๋ ์ ๋น๊ต ์
- { ์ปฌ๋ ์ ๊ฐ ์ฐ๊ด ๊ฒฝ๋ก } IS [NOT] EMPTY
- ์ปฌ๋ ์ ์ ๊ฐ์ด ๋น์์ผ๋ฉด ์ฐธ
-
์ปฌ๋ ์ ์ ๋ฉค๋ฒ ์
- { ์ํฐํฐ๋ ๊ฐ } [NOT] MEMBER [OF] { ์ปฌ๋ ์ ๊ฐ ์ฐ๊ด ๊ฒฝ๋ก }
- ์ํฐํฐ๋ ๊ฐ์ด ์ปฌ๋ ์ ์ ํฌํจ๋์ด ์์ผ๋ฉด ์ฐธ
์ค์นผ๋ผ ์
์ซ์, ๋ฌธ์, ๋ ์ง, case, ์ํฐํฐ ํ์
๊ฐ์ ๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ธ ํ์
๋ค์ ์ค์นผ๋ผ๋ผ๊ณ ํ๋ค.
-
์ํ ์
- ๋จํญ ์ฐ์ฐ์, ์ฌ์น์ฐ์ฐ
-
๋ฌธ์ํจ์
- CONCAT, SUBSTRING, TRIM, LOWER, UPPER, LENGTH, LOCATE
-
์ํ ํจ์
- ABS, SQRT, MOD, SIZE, INDEX
-
๋ ์ง ํจ์
- ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ํ์ฌ ์๊ฐ์ ์กฐํํ๋ค.
- CURRENTDATE, CURRENTTIME, CURRENT_TIMESTAMP
CASE ์
ํน์ ์กฐ๊ฑด์ ๋ฐ๋ผ ๋ถ๊ธฐํ ๋ CASE ์์ ์ฌ์ฉํ๋ค.
-
๊ธฐ๋ณธ CASE
-
CASE {WHEN <์กฐ๊ฑด์> THEN <์ค์นผ๋ผ์>} + ELSE <์ค์นผ๋ผ์> END
-
-
์ฌํ CASE
- ์กฐ๊ฑด์์ ์ฌ์ฉํ ์ ์์ง๋ง, ๋ฌธ๋ฒ์ด ๋จ์ํ๋ค.
-
CASE <์กฐ๊ฑด๋์> + {WHEN <์ค์นผ๋ผ์1> THEN <์ค์นผ๋ผ์2>} + ELSE <์ค์นผ๋ผ์> END
-
COALESCE
- ์ค์นผ๋ผ์์ ์ฐจ๋ก๋๋ก ์กฐํํด์
null์ด ์๋๋ฉด ๋ฐํํ๋ค. COALESCE(<์ค์นผ๋ผ์> {,<์ค์นผ๋ผ์>}+)
- ์ค์นผ๋ผ์์ ์ฐจ๋ก๋๋ก ์กฐํํด์
-
NULLIF
- ๋ ๊ฐ์ด ๊ฐ์ผ๋ฉด
null์ ๋ฐํํ๊ณ ๋ค๋ฅด๋ฉด ์ฒซ ๋ฒ์งธ ๊ฐ์ ๋ฐํํ๋ค. - ์งํฉ ํจ์๋
null์ ํฌํจํ์ง ์์ ๋ณดํต ์งํฉ ํจ์์ ํจ๊ป ์ฌ์ฉํ๋ค. NULLIF(<์ค์นผ๋ผ์>, <์ค์นผ๋ผ์>)
- ๋ ๊ฐ์ด ๊ฐ์ผ๋ฉด
โฐ ๋คํ์ฑ ์ฟผ๋ฆฌ
JPQL๋ก ๋ถ๋ชจ ์ํฐํฐ๋ฅผ ์กฐํํ๋ฉด ๊ทธ ์์ ์ํฐํฐ๋ ํจ๊ป ์กฐํํ๋ค.
Item์ ์์ ์ํฐํฐ๋กBook,Album,Movie๊ฐ ์๋ค๊ณ ๊ฐ์ ํ๋ค.Item์ ์กฐํํ๋ฉด ๊ทธ ์์๋ ํจ๊ป ์กฐํํ๋ค.
TYPE
์ํฐํฐ์ ์์ ๊ตฌ์กฐ์์ ์กฐํ ๋์์ ํน์ ์์ ํ์
์ผ๋ก ํ์ ํ ๋ ์ฌ์ฉํ๋ค.
// Item ์ค Book, Movie๋ฅผ ์กฐํํ๋ผ.
// JPQL
select i from Item i
where type(i) IN (Book, Movie)
// SQL
SELECT i FROM Item i
WHERE i.DTYPE in ('B', 'M')
TREAT
JPA 2.1์ ์ถ๊ฐ๋ ๊ธฐ๋ฅ์ผ๋ก, ์๋ฐ์ ํ์
์บ์คํ
๊ณผ ๋น์ทํ๋ค. ์์ ๊ตฌ์กฐ์์ ๋ถ๋ชจ ํ์
์ ํน์ ์์ ํ์
์ผ๋ก ๋ค๋ฃฐ ๋ ์ฌ์ฉํ๋ค.
// JPQL
select i from Item i where treat(i as Book).author = 'kim'
- ๋ถ๋ชจ ํ์
์ธ
Item์ ์์ ํ์ ์ธBook์ผ๋ก ๋ค๋คauthorํ๋์ ์ ๊ทผํ ์ ์๋ค.
โฐ ์ฌ์ฉ์ ์ ์ ํจ์ ํธ์ถ(JPA 2.1)
function_invocation::= FUNCTION(function_name {, function_arg})
- Hibernate ๊ตฌํ์ฒด๋ฅผ ์ฌ์ฉํ๋ฉด ๋ฐฉ์ธ ํด๋์ค๋ฅผ ์์ํด์ ๊ตฌํํ๊ณ ์ฌ์ฉํ ๋ฐ์ดํฐ๋ฒ ์ด์ค ํจ์๋ฅผ ๋ฏธ๋ฆฌ ๋ฑ๋กํด์ผ ํ๋ค.
- ๊ทธ๋ฆฌ๊ณ
hibernate.dialect์ ํด๋น ๋ฐฉ์ธ์ ๋ฑ๋กํด์ผ ํ๋ค.
โฐ ๊ธฐํ ์ ๋ฆฌ
enum์ = ๋น๊ต ์ฐ์ฐ๋ง ์ง์ํ๋ค.- ์๋ฒ ๋๋ ํ์ ์ ๋น๊ต๋ฅผ ์ง์ํ์ง ์๋๋ค.
EMPTY STRING
JPA ํ์ค์ ''์ ๊ธธ์ด 0์ธ Empty String์ผ๋ก ์ ํ์ง๋ง, ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ๋ฐ๋ผ NULL ๋ก ์ฌ์ฉํ๋ ๋ฐ์ดํฐ๋ฒ ์ด์ค๋ ์์ด ํ์ธ์ด ํ์ํ๋ค.
NULL ์ ์
- ์กฐ๊ฑด์ ๋ง์กฑํ๋ ๋ฐ์ดํฐ๊ฐ ํ๋๋ ์๋ ๊ฒฝ์ฐ
NULL์ ์ ์ ์๋ ๊ฐ์ด๋ค.NULL๊ณผ์ ๋ชจ๋ ์ํ์ ๊ณ์ฐ ๊ฒฐ๊ณผ๋NULL์ด๋ค.Null == Null์ ์ ์ ์๋ ๊ฐ์ด๋ค.Null is Null์ ์ฐธ์ด๋ค.
โฐ ์ํฐํฐ ์ง์ ์ฌ์ฉ
๊ธฐ๋ณธ ํค ๊ฐ
๊ฐ์ฒด ์ธ์คํด์ค๋ ์ฐธ์กฐ ๊ฐ์ผ๋ก ์๋ณํ๊ณ , ํ
์ด๋ธ ๋ก์ฐ๋ ๊ธฐ๋ณธ ํค ๊ฐ์ผ๋ก ์๋ณํ๋ค.
- ๋ฐ๋ผ์ JPQL์์ ์ํฐํฐ ๊ฐ์ฒด๋ฅผ ์ง์ ์ฌ์ฉํ๋ฉด SQL์์๋ ํด๋น ์ํฐํฐ์ ๊ธฐ๋ณธ ํค ๊ฐ์ ์ฌ์ฉํ๋ค.
์ธ๋ ํค ๊ฐ
ํน์ ํ์ ์์๋ ํ์์ ์ฐพ๋ ์์ ๋ก ํ์ธํ๋ค.
Team team = em.find(Team.class, 1L);
String qlString = "select m from Member m where m.team = :team";
List resultList = em.createQuery(qlString)
.setParameter("team", team);
.getResultList();
- ๊ธฐ๋ณธ ํค ๊ฐ์ด 1L์ธ ํ ์ํฐํฐ๋ฅผ ํ๋ผ๋ฏธํฐ๋ก ์ฌ์ฉํ๊ณ ์๋ค.
m.team์ ํ์ฌteam_id๋ผ๋ ์ธ๋ ํค์ ๋งคํ๋์ด ์๋ค.
select m.* from Member m where m.team_id = ?
์ํฐํฐ ๋์ ์๋ณ์ ๊ฐ์ ์ง์ ์ฌ์ฉํ ์ ์๋ค.
String qlString = "select m from Member m where m.team.id = :teamId";
List resultList = em.createQuery(qlString)
.setParameter("teamId", 1L);
.getResultList();
m.team.id๋ฅผ ๋ณด๋ฉดMember์Team๊ฐ ๋ฌต์์ ์กฐ์ธ์ด ๋ฐ์ํ ๊ฒ ๊ฐ์ง๋ง,MEMBERํ ์ด๋ธ์ด ์ธ๋ ํค๋ฅผ ๊ฐ์ง๊ณ ์์ด ๋ฐ์ํ์ง ์๋๋ค.
m.team์ ์ฌ์ฉํ๋ ,m.team.id๋ฅผ ์ฌ์ฉํ๋ ์์ฑ๋๋ SQL์ ๊ฐ๋ค.
โฐ Named ์ฟผ๋ฆฌ: ์ ์ ์ฟผ๋ฆฌ
JPQL์ ํฌ๊ฒ ๋์ ์ฟผ๋ฆฌ์ ์ ์ ์ฟผ๋ฆฌ๋ก ๋๋ ์ ์๋ค.
-
๋์ ์ฟผ๋ฆฌ
- JPQL์ ๋ฌธ์๋ก ์์ฑํด์ ์ง์ ๋๊ธฐ๋ ๊ฒ
- ๋ฐํ์์ ํน์ ์กฐ๊ฑด์ ๋ฐ๋ผ ๋์ ์ผ๋ก ๊ตฌ์ฑํ ์ ์๋ค.
-
์ ์ ์ฟผ๋ฆฌ
- ๋ฏธ๋ฆฌ ์ ์ํ ์ฟผ๋ฆฌ์ ์ด๋ฆ์ ๋ถ์ฌํด ํ์ํ ๋ ์ฌ์ฉํ๋ ๊ฒ, Named ์ฟผ๋ฆฌ๋ผ ํ๋ค.
- ํ ๋ฒ ์ ์ํ๋ฉด ๋ณ๊ฒฝํ ์ ์๋ค.
Named ์ฟผ๋ฆฌ๋ ์ ํ๋ฆฌ์ผ์ด์ ๋ก๋ฉ ์์ ์ JPQL ๋ฌธ๋ฒ ์ฒดํฌ ํ ๋ฏธ๋ฆฌ ํ์ฑํด๋๋ค.
- ์ค๋ฅ๋ฅผ ๋นจ๋ฆฌ ํ์ธํ ์ ์๊ณ , ์ฌ์ฉํ๋ ์์ ์๋ ํ์ฑ๋ ๊ฒฐ๊ณผ๋ฅผ ์ฌ์ฌ์ฉํ์ฌ ์ฑ๋ฅ์ ์ด์ ๋ ์๋ค.
- ์ ์ SQL์ ์์ฑํ๋ฏ๋ก, ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ์กฐํ ์ฑ๋ฅ ์ต์ ํ์๋ ๋์์ด ๋๋ค.
Named ์ฟผ๋ฆฌ๋ฅผ ์ด๋
ธํ
์ด์
์ ์ ์
@NamedQuery annotation์ ์ฌ์ฉํ๋ค.
@Entity
@NamedQuery (
name = "Member.findByUsername",
query = "select m from Member m where m.username = :username")
public class Member {
...
}
name์ ์ด๋ฆ์ ๋ถ์ฌํ๊ณ ,query์ ์ฌ์ฉํ ์ฟผ๋ฆฌ๋ฅผ ์ ๋ ฅํ๋ค.- ์ฌ์ฉ ์์๋
em.createNamedQuery()๋ฉ์๋์ Named ์ฟผ๋ฆฌ ์ด๋ฆ์ ์ ๋ ฅํ์ฌ ์ฌ์ฉํ๋ค. - ์ฌ๋ฌ ๊ฐ์ ์ฟผ๋ฆฌ๋ฅผ ์ฌ์ฉํ๊ธฐ ์ํด์๋
@NamedQueriesannotation์ ์ฌ์ฉํ ์ ์๋ค.
์ํฐํฐ ์ด๋ฆ์ ์ฟผ๋ฆฌ ์ด๋ฆ ์์ ๋ถ์ฌ ์์์ฑ ์ ๋ ๋จ์๋ก ๊ด๋ฆฌ๋๋ Named ์ฟผ๋ฆฌ์ ์ถฉ๋์ ๋ฐฉ์งํ๋ค.
@NamedQuery annotation
lockMode: ์ฟผ๋ฆฌ ์คํ ์ ๋ฝ์ ๊ฑด๋ค. (default: NONE)hints: SQL ํํธ๊ฐ ์๋๋ผ JPA ๊ตฌํ์ฒด์๊ฒ ์ ๊ณตํ๋ ํํธ๋ค.
Named ์ฟผ๋ฆฌ๋ฅผ XML์ ์ ์
JPA์์ annotation์ผ๋ก ์์ฑํ ์ ์๋ ๊ฒ์ XML๋ก๋ ์์ฑํ ์ ์๋ค.
- ์๋ฐ์์ ๋ฉํฐ๋ผ์ธ ๋ฌธ์๋ฅผ ๋ค๋ฃจ๋ ๊ฒ์ ์๋นํ ๊ท์ฐฎ์๋ฐ, XML์ ์ฌ์ฉํ๋ ๊ฒ์ด ํ์ค์ ์ธ ๋์์ด ๋ ์ ์๋ค.
<!-- META-INF/ormMember.xml -->
<named-query name="Member.findByUsername">
<query><CDATA[
select m
from Member m
where m.username = :username
]></query>
</named-query>
<named-query name="Member.count">
<query>select count(m) from Member m</query>
</named-query>
์์ฑํ xml์ ์ธ์ํ๋๋ก ์ฝ๋๋ฅผ ์ถ๊ฐํ๋ค.
<!-- META-INF/persistence.xml -->
<persistence-unit name="jpabook">
<mapping-file>META-INF/ormMember.xml</mapping-file>
...
META-INF/orm.xml์ ๊ธฐ๋ณธ ๋งคํ ํ์ผ๋ก ์ธ์ํ๋ค.
ํ๊ฒฝ์ ๋ฐ๋ฅธ ์ค์
XML๊ณผ annotation์ ๊ฐ์ ์ค์ ์ด ์๋ค๋ฉด XML์ด ์ฐ์ ๊ถ์ ๊ฐ์ง๋ค.
๐ซ Criteria
JPQL์ ์๋ฐ ์ฝ๋๋ก ์์ฑํ๋๋ก ๋์์ฃผ๋ ๋น๋ ํด๋์ค API์ด๋ค.
- ๋ฌธ์๊ฐ ์๋ ์ฝ๋๋ก JPQL์ ์์ฑํด ๋ฌธ๋ฒ ์ค๋ฅ๋ฅผ ์ปดํ์ผ ๋จ๊ณ์์ ํ์ธํ ์ ์๋ค.
- ๋ฌธ์ ๊ธฐ๋ฐ์ JPQL๋ณด๋ค ๋์ ์ฟผ๋ฆฌ๋ฅผ ์์ ํ๊ฒ ์์ฑํ ์ ์๋ค.
- ์ฝ๋๊ฐ ๋ณต์กํ๊ณ ์ฅํฉํด์ ์ง๊ด์ ์ธ ์ดํด๊ฐ ์ด๋ ต๋ค๋ ๋จ์ ์ด ์๋ค.
โฐ Criteria ๊ธฐ์ด
Criteria API๋ javax.persistence.criteria ํจํค์ง์ ์๋ค.
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<Member> cq = cb.createQuery(Member.class); // ๋ฐํํ์
์ง์
Root<Member> m = cq.from(Member.class); // FROM ์
cq.select(m);
TypedQuery<Member> query = em.createQuery(cq);
List<Member> members = query.getResultList();
- Criteria ์ฟผ๋ฆฌ ์์ฑ์ ์ํด์๋ Criteria ๋น๋๋ฅผ ์ป์ด์ผ ํ๋ค. EntityManager๋ EntityManagerFactory์์ ์ป์ ์ ์๋ค.
- Criteria ์ฟผ๋ฆฌ ๋น๋์์ Criteria ์ฟผ๋ฆฌ๋ฅผ ์์ฑํ๋ค. ์ด๋ ๋ฐํ ํ์ ์ ์ง์ ํ ์ ์๋ค.
- FROM ์ ์ ์์ฑํ๋ค. ๋ฐํ๋ ๊ฐ์ ๋ณ์นญ์ด๊ณ , ์ด๋ฅผ ์กฐํ์ ์์์ ์ผ๋ก ์ก๋๋ค.
๊ฒ์ ์กฐ๊ฑด๊ณผ ์ ๋ ฌ ์กฐ๊ฑด์ ์ถ๊ฐํ๋ค.
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<Member> cq = cb.createQuery(Member.class);
Root<Member> m = cq.from(Member.class);
Predicate usernameEqual = cb.equal(m.get("username"), "ํ์1");
javax.persistence.criteria.Order ageDesc = cb.desc(m.get("age"));
cq.select(m)
.where(usernameEqual)
.orderBy(ageDesc);
List<Member> resultList = em.createQuery(cq).getResultList();
์ฟผ๋ฆฌ ๋ฃจํธ์ ๋ณ์นญ
- ์ฟผ๋ฆฌ ๋ฃจํธ๋ ์กฐํ์ ์์์ ์ด๋ค.
- ๋ณ์นญ์ ์ํฐํฐ์๋ง ๋ถ์ฌํ ์ ์๋ค.
m.get("age") ๋ฉ์๋๋ age ์ ํ์
์ ๋ณด๋ฅผ ๋ชจ๋ฅด๊ธฐ ๋๋ฌธ์ m.<Integer>get("age") ์ ๊ฐ์ด ์ ๋ค๋ฆญ์ผ๋ก ๋ฐํ ํ์
์ ๋ณด๋ฅผ ๋ช
์ํด์ผ ํ๋ค.(String ๊ฐ์ ๋ฌธ์ ํ์
์ ์ง์ ํ์ง ์์๋ ๋๋ค.)
โฐ Criteria ์ฟผ๋ฆฌ ์์ฑ
CriteriaBuilder.createQuery() ๋ฉ์๋๋ก Criteria ์ฟผ๋ฆฌ๋ฅผ ์์ฑํด ์ฌ์ฉํ๋ค.
-
CriteriaBuilderinterface๋ฅผ ๋ณด๋ฉด, ์ฟผ๋ฆฌ ์์ฑ ์ ํ๋ผ๋ฏธํฐ๋ก ์ฟผ๋ฆฌ ๊ฒฐ๊ณผ์ ๋ํ ๋ฐํญ ํ์ ์ ์ง์ ํ ์ ์๋ค.- ๋ฐํ ํ์
์ ์ง์ ํ๋ค๋ฉด,
em.createQuery()์์ ๋ฐํ ํ์ ์ ์ง์ ํ์ง ์์๋ ๋๋ค.
- ๋ฐํ ํ์
์ ์ง์ ํ๋ค๋ฉด,
-
๋ฐํ ํ์ ์ ์ง์ ํ ์ ์๊ฑฐ๋, ๋ฐํ ํ์ ์ด ๋ ์ด์์ด๋ฉด ํ์ ๋ช ์ ์์ด
Object๋ก ๋ฐํ๋ฐ๋๋ค.- ๋ฌผ๋ก ๋ฐํ ํ์
์ด ๋ ์ด์๋ฏธ๋
Object[]๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด ํธ๋ฆฌํ๋ค.
- ๋ฌผ๋ก ๋ฐํ ํ์
์ด ๋ ์ด์๋ฏธ๋
โฐ ์กฐํ
CriteriaQuery interface ์ select , multiselect ๋ฉ์๋
์กฐํ ๋์์ ํ ๊ฑด, ์ฌ๋ฌ ๊ฑด ์ง์
select์ ์กฐํ ๋์์ ํ๋๋ง ์ง์ ํ๋ ค๋ฉดcq.select(m)๊ณผ ๊ฐ์ด ์์ฑํ๋ค.-
์กฐํ ๋์์ ์ฌ๋ฌ ๊ฑด ์ง์ ํ๋ ค๋ฉด
cq.multiselect(m.get("username"), m.get("age"));๊ณผ ๊ฐ์ด ์์ฑํ๋ค.- ์ฌ๋ฌ ๊ฑด ์ง์ ์
cb.array์ฌ์ฉ๋ ๊ฐ๋ฅํ๋ค.
- ์ฌ๋ฌ ๊ฑด ์ง์ ์
DISTINCT
select , multiselect ๋ค์์ distinct(true) ๋ก ์ฌ์ฉํ๋ค.
NEW, construct()
JPQL์์ select new ์์ฑ์() ๊ตฌ๋ฌธ์ Criteria์์๋ cb.construct(ํด๋์ค ํ์
, ...) ๋ก ์ฌ์ฉํ๋ค.
ํํ
Criteria๋ Map ๊ณผ ๋น์ทํ ํํ์ด๋ผ๋ ํน๋ณํ ๋ฐํ ๊ฐ์ฒด๋ฅผ ์ ๊ณตํ๋ค.
CriteriaQuery<Tuple> cq = cb.createTupleQuery();
cq.multiselect (
m.get("username").alias("username"), // ํํ์์ ์ฌ์ฉํ ๋ณ์นญ ์ง์
m.get("age").alias("age")
);
TypedQuery<Tuple> query = em.createQuery(cq);
List<Tuple> resultList = query.getResultList();
for (Tuple tuple : resultList) {
// ํํ ๋ณ์นญ์ผ๋ก ์กฐํ
String username = tuple.get("username", String.class);
Integer age = tuple.age("age", Integer.class);
}
- ํํ์ ์ฌ์ฉํ๋ ค๋ฉด
cb.createTupleQuery๋๋cb.createQuery(Tuple.class)๋ก Criteria๋ฅผ ์์ฑํ๋ค. - ํํ์ ํํ์ ๊ฒ์ ํค๋ก ์ฌ์ฉํ ํํ ์ ์ฉ ๋ณ์นญ์ ํ์๋ก ํ ๋นํด์ผ ํ๋ค.
- ์ ์ธํด๋ ํํ ๋ณ์นญ์ผ๋ก ๋ฐ์ดํฐ๋ฅผ ์กฐํํ๋ค.
- ํํ์ ์ด๋ฆ ๊ธฐ๋ฐ์ผ๋ก, ์์ ๊ธฐ๋ฐ์
Object[]๋ณด๋ค ์์ ํ๋ค. tuple.getElements()๊ฐ์ ๋ฉ์๋๋ก ํ์ฌ ํํ์ ๋ณ์นญ๊ณผ ์๋ฐ ํ์ ๋ ์กฐํํ ์ ์๋ค.
โฐ ์งํฉ
GROUP BY
cq.groupBy(m.get("team").get("name"))
- JPQL์
group by m.team.name๊ณผ ๊ฐ๋ค.
HAVING
cq.multiselect(m.get("team").get("name"), maxAge, minAge)
.groupBy(m.get("team").get("name"))
.having(cb.gt(minAge, 10));
- JPQL์
having min(m.age) > 10๊ณผ ๊ฐ๋ค.
โฐ ์ ๋ ฌ
cb.desc()... ๋๋ cb.asc(...) ๋ก ์์ฑํ ์ ์๋ค.
โฐ ์กฐ์ธ
join() ๋ฉ์๋์ JoinType ํด๋์ค๋ฅผ ์ฌ์ฉํ๋ค.
public enum JoinType {
INNER, (default)
LEFT,
RIGHT
}
Root<Member> m = cq.from(Member.class);
Join<Member, Team> t = m.join("team", JoinType.INNER); // ๋ด๋ถ ์กฐ์ธ ์ค์
cq.multiselect(m, t);
.where(cb.equal(t.get("name"), "ํA"));
FETCH JOIN์ ๋ค์๊ณผ ๊ฐ์ด ์ค์ ํ๋ค.
Root<Member> m = cq.from(Member.class);
m.fetch("team", JoinType.LEFT);
cq.select(m);
โฐ ์๋ธ ์ฟผ๋ฆฌ
๊ฐ๋จํ ์๋ธ ์ฟผ๋ฆฌ
๋ฉ์ธ ์ฟผ๋ฆฌ์ ์๋ธ ์ฟผ๋ฆฌ ๊ฐ ๊ด๋ จ์ด ์๋ ์๋ธ ์ฟผ๋ฆฌ๋ฅผ ๋งํ๋ค.
CriteriaQuery<Member> mainQuery = cb.createQuery(Member.class);
Subquery<Double> subQuery = mainQuery.subquery(Double.class);
Root<Member> m2 = subQuery.from(Member.class);
subQuery.select(cb.avg(m2.<Integer>get("age")));
Root<Member> m = mainQuery.from(Member.class);
mainQuery.select(m)
.where(cb.ge(m.<Integer>get("age"), subQuery));
- ์๋ธ ์ฟผ๋ฆฌ๋
mainQuery.subquery()๋ก ์์ฑํ๋ค. - ๋ฉ์ธ ์ฟผ๋ฆฌ๋
where(..., subQuery)์์ ์์ฑํ ์๋ธ ์ฟผ๋ฆฌ๋ฅผ ์ฌ์ฉํ๋ค.
์ํธ ๊ด๋ จ ์๋ธ ์ฟผ๋ฆฌ
๋ฉ์ธ ์ฟผ๋ฆฌ์ ์๋ธ ์ฟผ๋ฆฌ ๊ฐ ๊ด๋ จ์ด ์๋ ๊ฒฝ์ฐ์ด๋ค.
-
์๋ธ ์ฟผ๋ฆฌ์์ ๋ฉ์ธ ์ฟผ๋ฆฌ์ ์ ๋ณด๋ฅผ ์ฌ์ฉํ๋ ค๋ฉด ๋ฉ์ธ ์ฟผ๋ฆฌ์์ ์ฌ์ฉํ ๋ณ์นญ์ ์ป์ด์ผ ํ๋ค.
- ๋ฉ์ธ ์ฟผ๋ฆฌ์
Root๋Join์ ํตํด ์์ฑ๋ ๋ณ์นญ์ ๋ฐ์ ์ฌ์ฉํ๋ค. ์ด๋Root<Member> subM = subQuery.correlate(m);์ ์ฌ์ฉํด ๋ฉ์ธ ์ฟผ๋ฆฌ์ ๋ณ์นญ์ ๊ฐ์ ธ์ฌ ์ ์๋ค.
- ๋ฉ์ธ ์ฟผ๋ฆฌ์
โฐ IN ์
Criteria ๋น๋์์ in(...) ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ค.
โฐ CASE ์
selectCase() ๋ฉ์๋์ when() , otherwise() ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ค.
โฐ ํ๋ผ๋ฏธํฐ ์ ์
JPQL์์ :PARAM1 ์ฒ๋ผ ํ๋ผ๋ฏธํฐ๋ฅผ ์ ์ํ๋ฏ ์ ์ํ ์ ์๋ค.
cq.select(m)
.where(cb.equal(m.get("username"), cb.parameter(String.class, "usernameParam"))); // ํ๋ผ๋ฏธํฐ ์ ์
List<Member> resultList = em.createQuery(cq)
.setParameter("usernameParam", "ํ์1") // ๋ฐ์ธ๋ฉ
.getResultList();
โฐ ๋ค์ดํฐ๋ธ ํจ์ ํธ์ถ
๋ค์ดํฐ๋ธ SQL ํจ์ ํธ์ถ์ ์ํด์๋ cb.function(...) ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ฉด ๋๋ค.
โฐ ๋์ ์ฟผ๋ฆฌ
๋ค์ํ ๊ฒ์ ์กฐ๊ฑด์ ๋ฐ๋ผ ์คํ ์์ ์ ์ฟผ๋ฆฌ๋ฅผ ์์ฑํ๋ ๊ฒ์ ๋์ ์ฟผ๋ฆฌ๋ผ ํ๋ค.
- ์ฝ๋ ๊ธฐ๋ฐ์ธ Criteria๋ก ์์ฑํ๋ ๊ฒ์ด ํธ๋ฆฌํ๋ค.
- ๊ณต๋ฐฑ์ด๋
where,and์ ์์น๋ก ์ธํ ์๋ฌ๊ฐ ๋ฐ์ํ์ง๋ ์๋๋ค. - ํ์ง๋ง ์ฅํฉํ๊ณ ๋ณต์กํ๋ค๋ ๋จ์ ์ด ํฌ๋ค.
โฐ ํจ์ ์ ๋ฆฌ
Criteria๋ JPQL ๋น๋ ์ญํ ์ ํด JPQL ํจ์๋ฅผ ์ฝ๋๋ก ์ง์ํ๋ค.
- Expression์ ๋ฉ์๋(
isNull(),isNotNull(),in()) - ์กฐ๊ฑด ํจ์
- ์ค์นผ๋ผ์ ๊ธฐํ ํจ์
- ์งํฉ ํจ์
- ๋ถ๊ธฐ ํจ์
โฐ Criteria ๋ฉํ ๋ชจ๋ธ API
์ฝ๋ ๊ธฐ๋ฐ์ Criteria๋ ์ปดํ์ผ ์์ ์ ์ค๋ฅ๋ฅผ ๋ฐ๊ฒฌํ ์ ์๋ค.
-
ํ์ง๋ง
m.get("age")์์age๋ ๋ฌธ์๋ค. ์ด๋ฅผaggeadf๋ผ๊ณ ์ ์ด๋ ์ปดํ์ผ ์์ ์ ์๋ฌ๋ฅผ ๋ฐ๊ฒฌํ์ง ๋ชปํ๋ค.- ๋ฐ๋ผ์ ์์ ํ ์ฝ๋ ๊ธฐ๋ฐ์ด๋ผ ํ ์ ์๋ค.
- ์ด๋ฐ ๋ถ๋ถ๊น์ง ์ฝ๋๋ก ์์ฑํ๊ธฐ ์ํด์๋ ๋ฉํ ๋ชจ๋ธ API๋ฅผ ์ฌ์ฉํ๋ฉด ๋๋ค. ๋จผ์ ๋ฉํ ๋ชจ๋ธ ํด๋์ค๋ฅผ ์์ฑํ๋ค.
๋ฉํ ๋ชจ๋ธ API ์ ์ฉ ์
cq.select(m)
.where(cb.gt(m.<Integer>get("username"), 20))
.orderBy(cb.desc(m.get("age")));
๋ฉํ ๋ชจ๋ธ API ์ ์ฉ ํ
cq.select(m)
.where(cb.gt(m.get(Member_.age),20))
.orderBy(cb.desc(m.get(Member_.age)));
-
๋ฌธ์ ๊ธฐ๋ฐ์์ ์ ์ ์ธ ์ฝ๋ ๊ธฐ๋ฐ์ผ๋ก ๋ณ๊ฒฝ๋์๋ค.
- ์ด๋ฅผ ์ํด์๋
Member_ํด๋์ค๊ฐ ํ์ํ๋ฐ, ์ด๋ฅผ ๋ฉํ ๋ชจ๋ธ ํด๋์ค๋ผ ํ๋ค.
- ์ด๋ฅผ ์ํด์๋
-
๋ฉํ ๋ชจ๋ธ ํด๋์ค๋ ํด๋น ์ํฐํฐ๋ฅผ ๊ธฐ๋ฐ์ด๊ณ , ์ฝ๋ ์๋ ์์ฑ๊ธฐ๊ฐ
์ํฐํฐ๋ช _.java๋ชจ์์ ๋ฉํ ๋ชจ๋ธ ํด๋์ค๋ฅผ ์์ฑํด์ค๋ค.- Hibernate ๊ตฌํ์ฒด๋
org.hibernate.jpamodelgen.JPAMetaModelEntityProcessor๋ฅผ ์ฌ์ฉํ๋ค.
- Hibernate ๊ตฌํ์ฒด๋
์ฝ๋ ์์ฑ๊ธฐ ์ค์
๋ณดํต ๋ฉ์ด๋ธ์ด๋ ์ํธ, ๊ทธ๋๋ค ๊ฐ์ ๋น๋ ๋๊ตฌ๋ฅผ ์ฌ์ฉํด ์ฝ๋ ์์ฑ๊ธฐ๋ฅผ ์คํํ๋ค.
- ๋ฉ์ด๋ธ์ ๊ธฐ์ค์ผ๋ก,
hibernate-jpamodelgen๊ณผmaven-compiler-plugin์ค์ ์ ์ถ๊ฐํ๋ค. mvn compile๋ช ๋ น์ด๋ฅผ ์ฌ์ฉํด ๋ฉํ ๋ชจ๋ธ ํด๋์ค๋ฅผ ์์ฑํ๋ค.
๐ซ QueryDSL
JPQ Criteria๋ ๋ฌธ์๊ฐ ์๋ ์ฝ๋๋ก JPQL๋ฅผ ์์ฑํ์ฌ ๋ฌธ๋ฒ ์ค๋ฅ๋ฅผ ์ปดํ์ผ ๋จ๊ณ์์ ์ก์ ์ ์๊ณ , IDE ์๋์์ฑ ๊ธฐ๋ฅ์ ๋์์ ๋ฐ์ ์ ์๋ ๋ฑ ์ฌ๋ฌ ์ฅ์ ์ด ์์ง๋ง, ๋ณต์กํ๊ณ ์ฅํฉํ๋ค๋ ํฐ ๋จ์ ์ด ์กด์ฌํ๋ค.
์ฟผ๋ฆฌ๋ฅผ ๋ฌธ์๊ฐ ์๋ ์ฝ๋๋ก ์์ฑํด๋, ์ฝ๊ณ ๊ฐ๊ฒฐํ๋ฉฐ ๊ทธ ๋ชจ์๋ ์ฟผ๋ฆฌ์ ๋น์ทํ๊ฒ ๊ฐ๋ฐํ ์ ์๋ ํ๋ก์ ํธ๊ฐ ๋ฐ๋ก QueryDSL์ด๋ค.
- JPQL ๋น๋ ์ญํ ์ ํ๋๋ฐ, JPA Criteria๋ฅผ ๋์ฒดํ ์ ์๋ค.
- ์ฟผ๋ฆฌ ์ฆ ๋ฐ์ดํฐ๋ฅผ ์กฐํํ๋๋ฐ ๊ธฐ๋ฅ์ด ํนํ๋์ด ์๋ค.
โฐ QueryDSL ์ค์
gradle ๊ธฐ์ค!
๐ ํ์ ๋ผ์ด๋ธ๋ฌ๋ฆฌ
implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
implementation 'com.querydsl:querydsl-jpa'
implementation 'com.querydsl:querydsl-apt'
querydsl-jpa: QueryDSL JPA ๋ผ์ด๋ธ๋ฌ๋ฆฌquerydsl-apt: ์ฟผ๋ฆฌ ํ์ (Q)์ ์์ฑํ ๋ ํ์ํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ
๐ ํ๊ฒฝ์ค์
QueryDSL์ ์ฌ์ฉํ๊ธฐ ์ํด์๋ Criteria์ ๋ฉํ ๋ชจ๋ธ์ฒ๋ผ ์ํฐํฐ๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ์ฟผ๋ฆฌ ํ์
์ด๋ผ๋ ์ฟผ๋ฆฌ์ฉ ํด๋์ค๋ฅผ ์์ฑํด์ผ ํ๋ค. (Qํด๋์ค๋ผ๊ณ ๋ ํ๋ค.)
build.gradle์ ์ฟผ๋ฆฌ ํ์ ์ ์์ฑํ ์์น๋ฅผ ์ง์ ํ๊ณ ,Gradle->buildํ๋ฉด ์ฟผ๋ฆฌ ํ์ ์ด ํด๋น ๊ฒฝ๋ก์ ์์ฑ๋๋ค.
// queryDSL์ด ์์ฑํ๋ QClass ๊ฒฝ๋ก ์ค์
def querydslDir = "$buildDir/generated/querydsl"
querydsl {
library = "com.querydsl:querydsl-apt"
jpa = true
querydslSourcesDir = querydslDir
}
sourceSets {
main.java.srcDir querydslDir
}
configurations {
querydsl.extendsFrom compileClasspath
}
compileQuerydsl {
options.annotationProcessorPath = configurations.querydsl
}
import com.querydsl.jpa.impl.JPAQueryFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
@Configuration
public class QuerydslConfig {
@PersistenceContext
private EntityManager em;
@Bean
public JPAQueryFactory jpaQueryFactory() {
return new JPAQueryFactory(em);
}
}
- ๊ทธ๋ฆฌ๊ณ ์ํฐํฐ ๋งค๋์ ๋ฅผ ์ฃผ์ ํ JPAQueryFactory๋ฅผ Bean์ผ๋ก ๋ฑ๋กํ์ฌ ํ๋ก์ ํธ ์ ์ญ์์ QueryDSL์ ์์ฑํ ์ ์๊ฒ ํ๋ค.
โฐ ์์
public void queryDSL() {
...
EntityManager em = emf.createEntityManager();
JPAQuery query = new JPAQuery(em);
QMember qMember = new QMember("m");
List<Member> members =
query.from(qMember)
.where(qMember.name.eq("ํ์1"))
.orderBy(qMember.name.desc())
.list(qMember);
}
- QueryDSL์ ์ฌ์ฉํ๊ธฐ ์ํด์๋
JPAQuery๊ฐ์ฒด๋ฅผ ์์ฑํด์ผ ํ๋๋ฐ, ์ด๋ ์ํฐํฐ ๋งค๋์ ๋ฅผ ์์ฑ์์ ๋๊ฒจ์ค๋ค. -
๊ทธ๋ฆฌ๊ณ ์ฌ์ฉํ ์ฟผ๋ฆฌ ํ์ ์ ์์ฑํ๋๋ฐ, ์์ฑ์์๋ ๋ณ์นญ์ ๋๊ฒจ์ค๋ค.
- ์ด ๋ณ์นญ์ JPQL์์ ๋ณ์นญ์ผ๋ก ์ฌ์ฉํ๋ค.
๐ ๊ธฐ๋ณธ Q ์์ฑ
์ฟผ๋ฆฌ ํ์
์ ์ฌ์ฉํ๊ธฐ ํธ๋ฆฌํ๋๋ก ๊ธฐ๋ณธ ์ธ์คํด์ค๋ฅผ ๋ณด๊ดํ๊ณ ์๋ค.
- ํ์ง๋ง ๊ฐ์ ์ํฐํฐ๋ฅผ ์กฐ์ธํ๊ฑฐ๋ ๊ฐ์ ์ํฐํฐ๋ฅผ ์๋ธ ์ฟผ๋ฆฌ์ ์ฌ์ฉํ๋ฉด ๊ฐ์ ๋ณ์นญ์ด ์ฌ์ฉ๋๋ฏ๋ก, ์ด๋๋ ๋ณ์นญ์ ์ง์ ์ง์ ํด์ ์ฌ์ฉํด์ผ ํ๋ค.
public class QMember extends EntityPathBase<Member> {
public static final QMember member = new QMember("member1");
...
}
QMember qMember = new QMember("m"); // ์ง์ ์ง์
QMember qMember = QMember.member; // ๊ธฐ๋ณธ ์ธ์คํด์ค ์ฌ์ฉ
- ์ฟผ๋ฆฌ ํ์ ์ ์์ ๊ฐ์ด ์ฌ์ฉํ ์ ์๋ค.
- ๊ธฐ๋ณธ ์ธ์คํด์ค๋ฅผ ์ฌ์ฉํ๋ฉด
import static์ ์ฌ์ฉํด ๋ ๊ฐ๊ฒฐํ ์ฝ๋๋ฅผ ์์ฑํ ์ ์๋ค.
โฐ ๊ฒ์ ์กฐ๊ฑด ์ฟผ๋ฆฌ
JPAQuery query = new JPAQuery(em);
QItem item = QItem.item;
List<Item> list = query.from(item)
.where(item.name.eq("์ข์ ์ํ").and(item.price.gt(20000)))
.list(item);
- QueryDSL์
where์ ์๋and๋or์ ์ฌ์ฉํ ์ ์๋ค. ๋ํ ์ฌ๋ฌ ๊ฒ์ ์กฐ๊ฑด์ ์ฌ์ฉํ ์ ์๋ค.
โฐ ๊ฒฐ๊ณผ ์กฐํ
์ฟผ๋ฆฌ ์์ฑ์ด ๋๋๊ณ ๊ฒฐ๊ณผ ์กฐํ ๋ฉ์๋๋ฅผ ํธ์ถํ๋ฉด ์ค์ ๋ฐ์ดํฐ๋ฒ ์ด์ค๋ฅผ ์กฐํํ๋ค.
- ๋ณดํต
uniqueResult()๋list()๋ฅผ ์ฌ์ฉํ๊ณ ํ๋ผ๋ฏธํฐ๋ก ํ๋ก์ ์ ๋์์ ๋๊ฒจ์ค๋ค. - ๊ฒฐ๊ณผ ์กฐํ API๋
com.mysema.query.Projectable์ ์ ์๋์ด ์๋ค.
uniqueResult()
- ์กฐํ ๊ฒฐ๊ณผ๊ฐ ํ ๊ฑด์ผ ๋ ์ฌ์ฉํ๋ค.
- ์กฐํ ๊ฒฐ๊ณผ๊ฐ ์์ผ๋ฉด
null์ ๋ฐํํ๊ณ ๊ฒฐ๊ณผ๊ฐ ํ๋ ์ด์์ด๋ฉดNonUniqueResultException์์ธ๊ฐ ๋ฐ์ํ๋ค.
singleResult()
uniqueResult()์ ๊ฐ์ง๋ง ๊ฒฐ๊ณผ๊ฐ ํ๋ ์ด์์ด๋ฉด ์ฒ์ ๋ฐ์ดํฐ๋ฅผ ๋ฐํํ๋ค.
list()
- ๊ฒฐ๊ณผ๊ฐ ํ๋ ์ด์์ผ ๋ ์ฌ์ฉํ๋ค.
- ๊ฒฐ๊ณผ๊ฐ ์์ผ๋ฉด ๋น ์ปฌ๋ ์ ์ ๋ฐํํ๋ค.
โฐ ํ์ด์ง๊ณผ ์ ๋ ฌ
QItem item = QItem.item;
query.from(item)
.where(item.price.gt(20000))
.orderBy(item.price.desc(), item.stockQuantity.asc())
.offset(10).limit(20)
.list(item);
- ์ ๋ ฌ์
orderBy(),asc(),desc()์ ์ฌ์ฉํ๋ค. -
ํ์ด์ง์
offset,limit๋ฅผ ์ฌ์ฉํ๋ค.restrict()๋ฉ์๋์new QueryModifiers(20L, 10L)๋ฅผ ํ๋ผ๋ฏธํฐ๋ก ์ฌ์ฉํด๋ ๋๋ค.- ํ๋ผ๋ฏธํฐ์
20L๊ณผ10L์ ๊ฐ๊ฐ limit, offset์ ์๋ฏธํ๋ค.
์ค์ ํ์ด์ง ์ฒ๋ฆฌ๋ฅผ ์ํด์๋ ๊ฒ์๋ ์ ์ฒด ๋ฐ์ดํฐ ์๋ฅผ ์์์ผ ํ๋ค.
-
์ด๋
list()๋์listResult()๋ฅผ ์ฌ์ฉํ๋ค.- ์ ์ฒด ๋ฐ์ดํฐ ์กฐํ๋ฅผ ์ํ
count์ฟผ๋ฆฌ๋ฅผ ํ ๋ฒ ๋ ์คํํ๋ค. - ๊ทธ๋ฆฌ๊ณ
SearchResults๋ฅผ ๋ฐํํ๋๋ฐ, ์ด ๊ฐ์ฒด์์ ์ ์ฒด ๋ฐ์ดํฐ ์(getTotal())๋ฅผ ์กฐํํ ์ ์๋ค.
- ์ ์ฒด ๋ฐ์ดํฐ ์กฐํ๋ฅผ ์ํ
โฐ ๊ทธ๋ฃน
groupBy ๋ฅผ ์ฌ์ฉํ๊ณ ๊ทธ๋ฃนํ๋ ๊ฒฐ๊ณผ๋ฅผ ์ ํํ๋ ค๋ฉด having ์ ์ฌ์ฉํ๋ค.
โฐ ์กฐ์ธ
innerJoin(join) , leftJoin , rightJoin , fullJoin ์ ์ฌ์ฉํ ์ ์๊ณ , ์ถ๊ฐ๋ก JPQL์ on ๊ณผ ์ฑ๋ฅ ์ต์ ํ๋ฅผ ์ํ fetch ์กฐ์ธ๋ ์ฌ์ฉํ ์ ์๋ค.
- ๊ธฐ๋ณธ ๋ฌธ๋ฒ์ ์ฒซ ๋ฒ์งธ ํ๋ผ๋ฏธํฐ์ ์กฐ์ธ ๋์์ ์ง์ ํ๊ณ , ๋ ๋ฒ์งธ ํ๋ผ๋ฏธํฐ์ ๋ณ์นญ์ผ๋ก ์ฌ์ฉํ ์ฟผ๋ฆฌ ํ์ ์ ์ง์ ํ๋ค.
// ๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ธ ์กฐ์ธ ๋ฐฉ๋ฒ
QOrder order = QOrder.order;
QMember member = QMember.member;
QOrderItem orderItem = QOrderItem.orderItem;
query.from(order)
.join(order.member, member)
.leftJoin(order.orderItems, orderItem)
.list(order);
// ์กฐ์ธ์ on์ ์ฌ์ฉํ ์
...
query.from(order)
.leftJoin(order.orderItems, orderItem)
.on(orderItem.count.gt(2))
.list(order);
// ํ์น ์กฐ์ธ์ ์ฌ์ฉํ ์
...
query.from(order)
.innerJoin(order.member, member).fetch()
.leftJoin(order.orderItems, orderItem).fetch()
.list(order);
// ์ธํ ์กฐ์ธ์ ์ฌ์ฉํ ์
QOrder order = QOrder.order;
QMember member = QMember.member;
query.from(order, member)
.where(order.member.eq(member))
.list(order);
โฐ ์๋ธ ์ฟผ๋ฆฌ
์๋ธ ์ฟผ๋ฆฌ๋ JPASubQuery ๋ฅผ ์์ฑํด ์ฌ์ฉํ๋ค.
- ๊ฒฐ๊ณผ๊ฐ ํ๋๋ฉด
unique(), ์ฌ๋ฌ ๊ฑด์ด๋ฉดlist()๋ฅผ ์ฌ์ฉํ๋ค.
// ์๋ธ ์ฟผ๋ฆฌ - ํ ๊ฑด
QItem item = QItem.item;
QItem itemSub = new QItem("itemSub");
query.from(item)
.where(item.price.eq(
new JPASubQuery().from(itemSub).unique(itemSub.price.max())
))
.list(item);
โฐ ํ๋ก์ ์ ๊ณผ ๊ฒฐ๊ณผ ๋ฐํ
๐ ํ๋ก์ ์ ๋์์ด ํ๋
- ํ๋ก์ ์ ๋์์ด ํ๋๋ฉด ํด๋น ํ์ ์ผ๋ก ๋ฐํํ๋ค.
๐ ์ฌ๋ฌ ์ปฌ๋ผ ๋ฐํ๊ณผ ํํ
-
ํ๋ก์ ์ ๋์์ผ๋ก ์ฌ๋ฌ ํ๋๋ฅผ ์ ํํ๋ฉด, QueryDSL์ ๊ธฐ๋ณธ์ผ๋ก Tuple์ ์ฌ์ฉํ๋ค.
List<Tuple>๋ก ๋ฐํ๋ฐ๋๋ค.- ์กฐํ ๊ฒฐ๊ณผ๋
tuple.get()๋ฉ์๋์ ์กฐํํ ์ฟผ๋ฆฌ ํ์ ์ ์ง์ ํ๋ฉด ๋๋ค.
๐ ๋น ์์ฑ
-
์ฟผ๋ฆฌ ๊ฒฐ๊ณผ๋ฅผ ์ํฐํฐ๊ฐ ์๋ ํน์ ๊ฐ์ฒด๋ก ๋ฐ๊ณ ์ถ๋ค๋ฉด, ๋น ์์ฑ(Bean population) ๊ธฐ๋ฅ์ ์ฌ์ฉํ๋ค.
- ํ๋กํผํฐ ์ ๊ทผ
- ํ๋ ์ง์ ์ ๊ทผ
- ์์ฑ์ ์ฌ์ฉ
- ์ํ๋ ๋ฐฉ๋ฒ ์ง์ ์ ์ํด์๋
com.mysema.query.types.Projections๋ฅผ ์ฌ์ฉํ๋ฉด ๋๋ค.
๋จผ์ ํ๋กํผํฐ ์ ๊ทผ(Setter) ๋ฐฉ์์ด๋ค.
QItem item = QItem.item;
List<ItemDTO> result = query.from(item).list(
Projections.bean(ItemDTO.class, item.name.as("username"), item.price));
Projections.bean()์ ์์ ์(Setter)๋ฅผ ์ฌ์ฉํด ๊ฐ์ ์ฑ์ด๋ค.- ์ฟผ๋ฆฌ ๊ฒฐ๊ณผ์ ๋งคํํ ํ๋กํผํฐ ์ด๋ฆ์ด ๋ค๋ฅด๋ค๋ฉด
as๋ฅผ ์ฌ์ฉํด์ ๋ณ์นญ์ ์ฌ์ฉํ๋ฉด ๋๋ค.
๋จผ์ ํ๋ ์ง์ ์ ๊ทผ ๋ฐฉ์์ด๋ค.
QItem item = QItem.item;
List<ItemDTO> result = query.from(item).list(
Projections.fields(ItemDTO.class, item.name.as("username"), item.price));
Projections.fields()๋ฅผ ์ฌ์ฉํด ํ๋์ ์ง์ ์ ๊ทผํด ๊ฐ์ ์ฑ์ด๋ค.- ํ๋๋ฅผ
private๋ก ์ค์ ํด๋ ๋์ํ๋ค.
๋จผ์ ์์ฑ์ ๋ฐฉ์์ด๋ค.
QItem item = QItem.item;
List<ItemDTO> result = query.from(item).list(
Projections.constructor(ItemDTO.class, item.name, item.price));
Projections.constructor()๋ ์์ฑ์๋ฅผ ์ฌ์ฉํ๋ค.- ์ง์ ํ ํ๋ก์ ์ ๊ณผ ํ๋ผ๋ฏธํฐ ์์๊ฐ ๊ฐ์ ์์ฑ์๊ฐ ํ์์ ์ด๋ค.
โฐ ์์ , ์ญ์ ๋ฐฐ์น ์ฟผ๋ฆฌ
JPQL ๋ฐฐ์น ์ฟผ๋ฆฌ์ ๊ฐ์ด ์์์ฑ ์ปจํ ์คํธ๋ฅผ ๋ฌด์ํ๊ณ ๋ฐ์ดํฐ๋ฒ ์ด์ค๋ฅผ ์ง์ ์ฟผ๋ฆฌํ๋ค๋ ์ ์ ์ ์ํด์ผ ํ๋ค.
- ์์ ๋ฐฐ์น ์ฟผ๋ฆฌ๋
com.mysema.query.jpa.impl.JPAUpdateClause๋ฅผ ์ฌ์ฉํ๊ณ , - ์ญ์ ๋ฐฐ์น ์ฟผ๋ฆฌ๋
com.mysema.query.jpa.impl.JPADeleteClause
โฐ ๋์ ์ฟผ๋ฆฌ
com.mysema.query.BooleanBuilder ๋ฅผ ์ฌ์ฉํ๋ฉด ํน์ ์กฐ๊ฑด์ ๋ฐ๋ฅธ ๋์ ์ฟผ๋ฆฌ๋ฅผ ํธ๋ฆฌํ๊ฒ ์์ฑํ ์ ์๋ค.
BooleanBuilder.and()๋ฉ์๋๋ก ์ฟผ๋ฆฌ๋ฅผ ๋ถ์ฌ ์์ฑํ ์ ์๋ค.
โฐ ๋ฉ์๋ ์์
๋ฉ์๋ ์์(Delegate methods) ๊ธฐ๋ฅ์ผ๋ก ์ฟผ๋ฆฌ ํ์ ์ ๊ฒ์ ์กฐ๊ฑด์ ์ง์ ์ ์ํ ์ ์๋ค.
public class ItemExpression {
@QueryDelegate(Item.class)
public static BooleanExpression isExpensive(QItem item, Integer price) {
return item.price.gt(price);
}
}
- ๋จผ์ ์ ์ (
static) ๋ฉ์๋๋ฅผ ๋ง๋ค๊ณ , @QueryDelegateannotation์ ์์ฑ์ผ๋ก ์ด ๊ธฐ๋ฅ์ ์ ์ฉํ ์ํฐํฐ๋ฅผ ์ง์ ํ๋ค.
๐ซ ๋ค์ดํฐ๋ธ SQL
JPQL์ ํ์ค SQL์ด ์ง์ํ๋ ๋๋ถ๋ถ์ ๋ฌธ๋ฒ๊ณผ SQL ํจ์๋ค์ ์ง์ํ์ง๋ง, ํน์ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ์ข ์์ ์ธ ๊ธฐ๋ฅ์ ์ง์ํ์ง ์๋๋ค.
- ํน์ ๋ฐ์ดํฐ๋ฒ ์ด์ค๋ง ์ง์ํ๋ ํจ์, ๋ฌธ๋ฒ, SQL ์ฟผ๋ฆฌ ํํธ
- ์ธ๋ผ์ธ ๋ทฐ(FROM ์ ์์ ์ฌ์ฉํ๋ ์๋ธ ์ฟผ๋ฆฌ), UNION, INTERSECT
- Stored procedure
ํ์ง๋ง ๋๋ก๋ ํน์ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ์ข ์์ ์ธ ๊ธฐ๋ฅ์ด ํ์ํ๋ฏ๋ก, ์๋์ ๊ฐ์ด JPA ๊ตฌํ์ฒด๋ค์ ๋ค์ํ ๋ฐฉ๋ฒ์ ์ง์ํ๋ค.(JPA๋ณด๋ค ๋ ๋ค์ํ ๋ฐฉ๋ฒ ์ง์)
-
ํน์ ๋ฐ์ดํฐ๋ฒ ์ด์ค๋ง ์ฌ์ฉํ๋ ํจ์
- JPQL์์ ๋ค์ดํฐ๋ธ SQL ํจ์๋ฅผ ํธ์ถํ ์ ์๋ค.
- Hibernate๋ ๋ฐ์ดํฐ๋ฒ ์ด์ค ๋ฐฉ์ธ์ ๊ฐ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ์ข ์์ ์ธ ํจ์๋ค์ ์ ์ํ๋ค. ๋ํ ์ง์ ์ ์ํ ์๋ ์๋ค.
-
ํน์ ๋ฐ์ดํฐ๋ฒ ์ด์ค๋ง ์ง์ํ๋ SQL ์ฟผ๋ฆฌ ํํธ
- Hibernate๋ฅผ ํฌํจํ ๋ช๋ช JPA ๊ตฌํ์ฒด๋ค์ด ์ง์ํ๋ค.
-
์ธ๋ผ์ธ ๋ทฐ(FROM์ ์์ ์ฌ์ฉํ๋ ์๋ธ ์ฟผ๋ฆฌ), UNION, INTERSECT
- ์ผ๋ถ JPA ๊ตฌํ์ฒด๋ค์ด ์ง์ํ๋ค.
-
Stored procedure
- JPQL์์ ํธ์ถํ ์ ์๋ค.
-
ํน์ ๋ฐ์ดํฐ๋ฒ ์ด์ค๋ง ์ง์ํ๋ ๋ฌธ๋ฒ
- ๋๋ฌด ์ข ์์ ์ธ SQL ๋ฌธ๋ฒ์ ์ง์ํ์ง ์์ ๋ค์ดํฐ๋ธ SQL์ ์ฌ์ฉํด์ผ ํ๋ค.
JPQL์ ์ฌ์ฉํ ์ ์์ ๋ JPA๋ SQL์ ์ง์ ์ฌ์ฉํ ์ ์๋ ๊ธฐ๋ฅ์ ์ ๊ณตํ๋๋ฐ ์ด๋ฅผ ๋ค์ดํฐ๋ธ SQL์ด๋ผ ํ๋ค.
- JPQL์ ์ฌ์ฉํ๋ฉด JPA๊ฐ SQL์ ์์ฑํ๋ค.
๐ JPA๊ฐ ์ง์ํ๋ ๋ค์ดํฐ๋ธ SQL๊ณผ JDBC API๋ฅผ ์ง์ ์ฌ์ฉํ๋ ๊ฒ์ ์ฐจ์ด
- ๋ค์ดํฐ๋ธ SQL์ ์ฌ์ฉํ๋ฉด ์ํฐํฐ๋ฅผ ์กฐํํ ์ ์๊ณ ,
- JPA๊ฐ ์ง์ํ๋ ์์์ฑ ์ปจํ ์คํธ์ ๊ธฐ๋ฅ์ ๊ทธ๋๋ก ์ฌ์ฉํ ์ ์๋ค.
โฐ ๋ค์ดํฐ๋ธ SQL ์ฌ์ฉ
๋ค์ดํฐ๋ธ ์ฟผ๋ฆฌ API๋ ๋ค์ 3๊ฐ์ง๊ฐ ์๋ค.
// ๊ฒฐ๊ณผ ํ์
์ ์
public Query createNativeQuery(String sqlString, Class resultClass);
// ๊ฒฐ๊ณผ ํ์
์ ์ ์ํ ์ ์๋ ๊ฒฝ์ฐ
public Query createNativeQuery(String sqlString);
// ๊ฒฐ๊ณผ ๋งคํ ์ฌ์ฉ
public Query createNativeQuery(String sqlString, String resultSetMapping);
๐ ์ํฐํฐ ์กฐํ
๋ค์ดํฐ๋ธ SQL์ em.createNativeQuery() ๋ฅผ ์ฌ์ฉํ๋ค.
- ์ฒซ ๋ฒ์งธ ํ๋ผ๋ฏธํฐ๋ ๋ค์ดํฐ๋ธ SQL์ ์ ๋ ฅํ๊ณ ,
- ๋ ๋ฒ์งธ ํ๋ผ๋ฏธํฐ๋ ์กฐํํ ์ํฐํฐ ํด๋์ค์ ํ์ ์ ์ ๋ ฅํ๋ค.
JPQL๊ณผ ํก์ฌํ์ง๋ง ์ค์ ๋ฐ์ดํฐ๋ฒ ์ด์ค SQL์ ์ฌ์ฉํ๋ค๋ ๊ฒ๊ณผ, ์์น๊ธฐ๋ฐ ํ๋ผ๋ฏธํฐ๋ง ์ง์ํ๋ค๋ ์ฐจ์ด๊ฐ ์๋ค.
"๊ฐ์ฅ ์ค์ํ ์ ์ ๋ค์ดํฐ๋ธ SQL๋ก SQL๋ง ์ง์ ์ฌ์ฉํ ๋ฟ์ด์ง ๋๋จธ์ง๋ JPQL์ ์ฌ์ฉํ ๋์ ๊ฐ๋ค. ์กฐํํ ์ํฐํฐ๋ ์์์ฑ ์ปจํ ์คํธ์์ ๊ด๋ฆฌ๋๋ค."
๐ ๊ฐ ์กฐํ
๊ฐ์ผ๋ก๋ง ์กฐํํ๋ ๊ฒฝ์ฐ em.createNativeQuery() ์ ๋ ๋ฒ์งธ ํ๋ผ๋ฏธํฐ๋ฅผ ์ฌ์ฉํ์ง ์์ผ๋ฉด ๋๋ค.
- ์กฐํํ ๊ฐ๋ค์
Object[]์ ๋ด์์ ๋ฐํ๋๋ค. - ์ค์นผ๋ผ ๊ฐ๋ค์ ์กฐํํ์ผ๋ฏ๋ก ์์์ฑ ์ปจํ ์คํธ์์ ๊ด๋ฆฌ๋์ง ์๋๋ค.
๐ ๊ฒฐ๊ณผ ๋งคํ ์ฌ์ฉ
์ํฐํฐ์ ์ค์นผ๋ผ ๊ฐ์ ํจ๊ป ์กฐํํ๋ ๊ฒฝ์ฐ์ฒ๋ผ ๋งคํ์ด ๋ณต์กํด์ง๋ฉด, @SqlResultSetMapping ์ ์ ์ํด์ ๊ฒฐ๊ณผ ๋งคํ์ ์ฌ์ฉํด์ผ ํ๋ค.
em.createNativeQuery()์ ๋ ๋ฒ์งธ ํ๋ผ๋ฏธํฐ์ ์ ์ํ ๊ฒฐ๊ณผ ๋งคํ ์ ๋ณด์ ์ด๋ฆ์ ์ฌ์ฉํ๋ค.
// ๊ฒฐ๊ณผ ๋งคํ ์ ์
@Entity
@SqlResultSetMapping(name = "memberWithOrderCount",
entities = {@EntityResult(entityClass = Member.class)},
columns = {@ColumnResult(name = "ORDER_COUNT")}
)
public class Member {...}
- ํ์ ์ํฐํฐ์
ORDER_COUNT์ปฌ๋ผ์ ๋งคํํ๋ค. - ์ฌ๋ฌ ์ํฐํฐ์ ์ปฌ๋ผ๋ค์ ๋งคํํ ์ ์๋ค.
๐ ๊ฒฐ๊ณผ ๋งคํ annotation
-
@SqlResultSetMapping์์ฑ- name : ๊ฒฐ๊ณผ ๋งคํ ์ด๋ฆ
- entities :
@EntityResult๋ฅผ ์ฌ์ฉํด์ ์ํฐํฐ๋ฅผ ๊ฒฐ๊ณผ๋ก ๋งคํํ๋ค. - columns :
@ColumnResult๋ฅผ ์ฌ์ฉํด์ ์ปฌ๋ผ์ ๊ฒฐ๊ณผ๋ก ๋งคํํ๋ค.
-
@EntityResult์์ฑ- entityClass : ๊ฒฐ๊ณผ๋ก ์ฌ์ฉํ ์ํฐํฐ ํด๋์ค๋ฅผ ์ง์ ํ๋ค.
- fields :
@FieldResult๋ฅผ ์ฌ์ฉํด์ ๊ฒฐ๊ณผ ์ปฌ๋ผ์ ํ๋์ ๋งคํํ๋ค. - discriminatorColumn : ์ํฐํฐ์ ์ธ์คํด์ค ํ์ ์ ๊ตฌ๋ถํ๋ ํ๋(์์์์ ์ฌ์ฉ)
-
@FieldResult์์ฑ- name : ๊ฒฐ๊ณผ๋ฅผ ๋ฐ์ ํ๋๋ช
- column : ๊ฒฐ๊ณผ ์ปฌ๋ผ๋ช
-
@ColumnResult์์ฑ- name : ๊ฒฐ๊ณผ ์ปฌ๋ผ๋ช
โฐ Named ๋ค์ดํฐ๋ธ SQL
JPQL์ฒ๋ผ Named ๋ค์ดํฐ๋ธ SQL์ ์ฌ์ฉํด์ ์ ์ SQL์ ์์ฑํ ์ ์๋ค.
- ์ด๋
@NamedNativeQueryannotation์ผ๋ก Named ๋ค์ดํฐ๋ธ SQL์ ๋ฑ๋กํ๋ค.
TypedQuery<Member> nativeQuery =
em.createNamedQuery("Member.memberSQL", Member.class)
.setParameter(1, 20);
- JPQL Named ์ฟผ๋ฆฌ์ ๊ฐ์
createNamedQuery๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ค. ๋ฐ๋ผ์TypeQuery๋ฅผ ์ฌ์ฉํ ์ ์๋ค. - ์ดํ Named ๋ค์ดํฐ๋ธ ์ฟผ๋ฆฌ์์
resultSetMapping์์ฑ์ ์ฌ์ฉํด์ ์กฐํ ๊ฒฐ๊ณผ๋ฅผ ๋งคํํ ๋์์ ์ง์ ํ ์ ์๋ค.
๐ @NamedNativeQuery
- name : Named ์ฟผ๋ฆฌ ์ด๋ฆ (ํ์)
- query : SQL ์ฟผ๋ฆฌ (ํ์)
- hints : ๋ฒค๋ ์ข ์์ ์ธ ํํธ
- resultClass : ๊ฒฐ๊ณผ ํด๋์ค
- resultSetMapping : ๊ฒฐ๊ณผ ๋งคํ ์ฌ์ฉ
โฐ ๋ค์ดํฐ๋ธ SQL XML์ ์ ์
XML์ ์ ์ ์,
<named-native-query>๋ฅผ ๋จผ์ ์ ์ํ๊ณ ,<sql-result-set-mapping>์ ์ ์ํด์ผ ํ๋ค.
โฐ ๋ค์ดํฐ๋ธ SQL ์ ๋ฆฌ
๋ค์ดํฐ๋ธ SQL๋ JPQL์ ์ฌ์ฉํ ๋์ ๋ง์ฐฌ๊ฐ์ง๋ก Query , TypeQuery(Named ๋ค์ดํฐ๋ธ ์ฟผ๋ฆฌ์ ๊ฒฝ์ฐ๋ง!)๋ฅผ ๋ฐํํ๋ค.
- ๋ฐ๋ผ์ JPQL API๋ฅผ ๊ทธ๋๋ก ์ฌ์ฉํ ์ ์๋ค.
๋ค์ดํฐ๋ธ SQL์ JPQL์ด ์๋ ์์ฑํ๋ SQL์ ์๋์ผ๋ก ์ง์ ์ ์ํ๋ ๊ฒ์ด๋ค.
- ๋ฐ๋ผ์ JPA๊ฐ ์ ๊ณตํ๋ ๊ธฐ๋ฅ ๋๋ถ๋ถ์ ๊ทธ๋๋ก ์ฌ์ฉํ ์ ์๋ค.
โฐ ์คํ ์ด๋ ํ๋ก์์
JPQ 2.1๋ถํฐ ์ง์ํ๋ค.
๐ ์คํ ์ด๋ ํ๋ก์์ ์ฌ์ฉ
์
๋ ฅ ๊ฐ์ ๋ ๋ฐฐ๋ก ์ฆ๊ฐ์์ผ ์ฃผ๋ ์คํ ์ด๋ ํ๋ก์์ ๊ฐ ์๋ค.
- ์ฒซ ๋ฒ์งธ ํ๋ผ๋ฏธํฐ๋ก ๊ฐ์ ์ ๋ ฅ๋ฐ๊ณ , ๋ ๋ฒ์งธ ํ๋ผ๋ฏธํฐ๋ก ๊ฒฐ๊ณผ๋ฅผ ๋ฐํํ๋ค.
DELIMITER //
CREATE PROCEDURE proc_multiply (INOUT inParam INT, INOUT outParam INT)
BEGIN
SET outParam = inParam * 2;
END //
JPA๋ก ์ด ์คํ ์ด๋ ํ๋ก์์ ๋ฅผ ํธ์ถํ๊ธฐ ์ํด์๋,
em.createStoredProcedureQuery()๋ฉ์๋์ ์ฌ์ฉํ ํ๋ก์์ ์ ์ด๋ฆ์ ๋ช ์ํ๋ค.-
๊ทธ๋ฆฌ๊ณ
registerStoredProcedureParameter()๋ฉ์๋๋ฅผ ์ฌ์ฉํด ํ๋ก์์ ์์ ์ฌ์ฉํ ํ๋ผ๋ฏธํฐ๋ฅผ ์์, ํ์ , ํ๋ผ๋ฏธํฐ ๋ชจ๋ ์์ผ๋ก ์ ์ํ๋ค.- ์์ ๋์ ์ ์ด๋ฆ์ ์ฌ์ฉํ ์๋ ์๋ค.
๐ Named ์คํ ์ด๋ ํ๋ก์์ ์ฌ์ฉ
์คํ ์ด๋ ํ๋ก์์ ์ฟผ๋ฆฌ์ ์ด๋ฆ์ ๋ถ์ฌํด์ ์ฌ์ฉํ๋ ๊ฒ์ ๋งํ๋ค.
@NamedStoredProcedureQuery๋ก ์ ์ํ๊ณ ,name์์ฑ์ผ๋ก ์ด๋ฆ์ ๋ถ์ฌํ๋ฉด ๋๋ค.procedureName์ ์ค์ ํธ์ถํ ํ๋ก์์ ์ ์ด๋ฆ์ ๋ช ์ํ๊ณ ,@StoredProcedureParameter๋ฅผ ์ฌ์ฉํด ํ๋ผ๋ฏธํฐ ์ ๋ณด๋ฅผ ์ ์ํ๋ฉด ๋๋ค.
๐ซ ๊ฐ์ฒด์งํฅ ์ฟผ๋ฆฌ ์ฌํ
ํ ๋ฒ์ ์ฌ๋ฌ ๋ฐ์ดํฐ๋ฅผ ์์ ํ ์ ์๋ "๋ฒํฌ ์ฐ์ฐ"๊ณผ JPQL๊ณผ ์์์ฑ ์ปจํ ์คํธ์ ๋ํด ๋ค๋ฃฌ๋ค. ๊ทธ๋ฆฌ๊ณ JPQL๊ณผ ํ๋ฌ์ ๋ชจ๋๋ฅผ ๋ค๋ฃฌ๋ค.
โฐ ๋ฒํฌ ์ฐ์ฐ
์ํฐํฐ๋ฅผ ์์ ํ๋ ค๋ฉด ์์์ฑ ์ปจํ
์คํธ์ ๋ณ๊ฒฝ ๊ฐ์ง ๊ธฐ๋ฅ์ด๋ ๋ณํฉ์ ์ฌ์ฉํ๊ณ , ์ญ์ ํ๋ ค๋ฉด em.remove() ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ค.
- ํ์ง๋ง ์์ฒญ๋๊ฒ ๋ง์ ์ํฐํฐ๋ฅผ ์ฒ๋ฆฌํ๊ธฐ์๋ ๋ง์ ์๊ฐ ๋น์ฉ์ด ๋ ๋ค.
- ์ด๋ด ๋ ์ฌ์ฉํ๋ ๊ฒ์ด ๋ฒํฌ ์ฐ์ฐ์ด๋ค.
// UPDATE ๋ฒํฌ ์ฐ์ฐ
String qlString =
"update Product p " +
"set p.price = p.price * 1.1 " +
"where p.stockAmount > :stockAmount";
int resultCount = em.createQuery(qlString)
.setParameter("stockAmount", 10)
.executeUpdate();
-
๋ฒํฌ ์ฐ์ฐ์
executeUpdate()๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ค.- ๋ฒํฌ ์ฐ์ฐ์ผ๋ก ์ํฅ ๋ฐ์ ์ํฐํฐ์ ๊ฑด์๋ฅผ ๋ฐํํ๋ค.
- ์ญ์ ๋ํ ๊ฐ์ ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ค.
JPA ํ์ค์ ์๋์ง๋ง Hibernate๋ INSERT ๋ฒํฌ ์ฐ์ฐ๋ ์ง์ํ๋ค.
๐ ๋ฒํฌ ์ฐ์ฐ์ ์ฃผ์์
๋ฒํฌ ์ฐ์ฐ์ด ์์์ฑ ์ปจํ
์คํธ๋ฅผ ๋ฌด์ํ๊ณ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ์ง์ ์ฟผ๋ฆฌํ๋ค๋ ์ ์ ์ฃผ์ํด์ผ ํ๋ค.
- ๋ฐ๋ผ์ ์์์ฑ ์ปจํ ์คํธ์ ์๋ ๊ฐ๊ณผ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ์๋ ๊ฐ์ด ๋ค๋ฅผ ์ ์๋ค.
- ์๋๋ ๊ทธ ํด๊ฒฐ๋ฐฉ๋ฒ๋ค์ด๋ค.
em.refresh() ์ฌ์ฉ
- ๋ฒํฌ ์ฐ์ฐ์ ์ํํ ์งํ, ์ ํํ ์ํฐํฐ๋ฅผ ์ฌ์ฉํด์ผ ํ๋ค๋ฉด,
em.refresh()๋ฅผ ์ฌ์ฉํด ๋ฐ์ดํฐ๋ฒ ์ด์ค์์ ํด๋น ์ํฐํฐ๋ฅผ ๋ค์ ์กฐํํ๋ฉด ๋๋ค.
๋ฒํฌ ์ฐ์ฐ ๋จผ์ ์คํ
- ๊ฐ์ฅ ์ค์ฉ์ ์ธ ํด๊ฒฐ์ฑ ์ด๋ค.
- ๋ฒํฌ ์ฐ์ฐ์ ์คํํ๊ณ ๋ ๋ค, ์ํฐํฐ๋ฅผ ์กฐํํ์ฌ ๋ ๊ฐ์ด ๊ฐ๋๋ก ํด์ค๋ค.
๋ฒํฌ ์ฐ์ฐ ์ํ ํ ์์์ฑ ์ปจํ ์คํธ ์ด๊ธฐํ
- ๋ฒํฌ ์ฐ์ฐ ์ํ ์งํ ์์์ฑ ์ปจํ ์คํธ๋ฅผ ์ด๊ธฐํํด์ ๋จ์ ์๋ ์ํฐํฐ๋ฅผ ์ ๊ฑฐํ๋ ๊ฒ๋ ์ข์ ๋ฐฉ๋ฒ์ด๋ค.
- ์ด๊ธฐํํ ํ ์ํฐํฐ๋ฅผ ์กฐํํ๊ฒ ๋๋ฉด, ๋ฒํฌ ์ฐ์ฐ์ด ์ ์ฉ๋ ๋ฐ์ดํฐ๋ฒ ์ด์ค์์ ์ํฐํฐ๋ฅผ ์กฐํํ ๊ฒ์ด๋ค.
โฐ ์์์ฑ ์ปจํ ์คํธ์ JPQL
๐ ํด๋ฆฌ ํ ์์ ์ํ์ธ ๊ฒ๊ณผ ์๋ ๊ฒ
JPQL๋ก ์ํฐํฐ๋ฅผ ์กฐํํ๋ฉด ์์์ฑ ์ปจํ
์คํธ์์ ๊ด๋ฆฌ๋์ง๋ง ๊ทธ๋ ์ง ์์ ๊ฒฝ์ฐ๋ ๊ด๋ฆฌ๋์ง ์๋๋ค.
์กฐํํ ์ํฐํฐ๋ง ์์์ฑ ์ปจํ ์คํธ๊ฐ ๊ด๋ฆฌํ๊ณ , ๋ณ๊ฒฝ ๊ฐ์ง๊ฐ ๋ฐ์ํ๋ค.
๐ JPQL๋ก ์กฐํํ ์ํฐํฐ์ ์์์ฑ ์ปจํ
์คํธ
์์์ฑ ์ปจํ
์คํธ์ ์ด๋ฏธ ํน์ ์ํฐํฐ๊ฐ ์๋ ๊ฒฝ์ฐ์ ๋์ผํ ์ํฐํฐ๋ฅผ JPQL๋ก ์กฐํํ๋ค๋ฉด?
-
์ด๋ฏธ ์์์ฑ ์ปจํ ์คํธ์ ๋์ผํ ์ํฐํฐ๊ฐ ์๋ ๊ฒฝ์ฐ, JPQL๋ก ๋ฐ์ดํฐ๋ฒ ์ด์ค์์ ์กฐํํ ๊ฒฐ๊ณผ๋ฅผ ๋ฒ๋ฆฌ๊ณ , ์์์ฑ ์ปจํ ์คํธ์ ์๋ ์ํฐํฐ๋ฅผ ๋ฐํํ๋ค.
- ์ด๋ ์๋ณ์ ๊ฐ์ ์ฌ์ฉํด์ ๋น๊ตํ๋ค.
JPQL๋ก ์กฐํํ ์๋ก์ด ์ํฐํฐ๋ฅผ ์์์ฑ ์ปจํ ์คํธ์ ํ๋ ๋ ์ถ๊ฐํ๊ฑฐ๋, ๊ธฐ์กด ์ํฐํฐ๋ฅผ ์๋ก ๊ฒ์ํ ์ํฐํฐ๋ก ๋์ฒดํ๋ฉด ์ด๋ค ๋ฌธ์ ๊ฐ ๋ฐ์ํ๋ ๊ฒ์ผ๊น?
-
์์์ฑ ์ปจํ ์คํธ๋ ๊ธฐ๋ณธ ํค ๊ฐ์ ๊ธฐ์ค์ผ๋ก ์ํฐํฐ๋ฅผ ๊ด๋ฆฌํ๋ค.
- ๋ฐ๋ผ์ ๊ฐ์ ๊ธฐ๋ณธ ํค ๊ฐ์ ๊ฐ์ง ์ํฐํฐ๋ ๋ฑ๋ก์ด ๋ถ๊ฐํ๋ค. โ "์๋ก์ด ์ํฐํฐ ๋ ์ถ๊ฐ ๋ถ๊ฐ๋ฅ"
-
์์์ฑ ์ปจํ ์คํธ๋ ์ํฐํฐ์ ๋์ผ์ฑ์ ๋ณด์ฅํ๋ค.
- ์์์ฑ ์ปจํ ์คํธ์ ์์ ์ค์ธ ๋ฐ์ดํฐ๊ฐ ์ฌ๋ผ์ง ์ํ์ด ์กด์ฌํ๋ ํ์๋ ๋ถ๊ฐํ๋ค. โ "์๋ก์ด ์ํฐํฐ๋ก ๋์ฒด ๋ถ๊ฐ๋ฅ"
์ด๋ฌํ ์ด์ ๋ก ๊ธฐ์กด ์ํฐํฐ๋ ๊ทธ๋๋ก ๋๊ณ ์๋ก ๊ฒ์ํ ์ํฐํฐ๋ฅผ ๋ฒ๋ฆฌ๋ ์ ์ฑ ์ ๋ฐ๋ฅธ๋ค.
๐ find() vs. JPQL
em.find() ๋ฉ์๋๋ ์ํฐํฐ๋ฅผ ์์์ฑ ์ปจํ
์คํธ์์ ๋จผ์ ์ฐพ๊ณ , ์๋ค๋ฉด ๋ฐ์ดํฐ๋ฒ ์ด์ค์์ ์กฐํํ๋ค.
- ๋ฐ๋ผ์ ์์์ฑ ์ปจํ ์คํธ์ ์ฐพ์ผ๋ ค๋ ์ํฐํฐ๊ฐ ์๋ค๋ฉด, ๋ฉ๋ชจ๋ฆฌ์์ ๋ฐ๋ก ์ฐพ์ผ๋ฏ๋ก ์ฑ๋ฅ์ ์ด์ ์ด ์๋ค. (1์ฐจ ์บ์)
ํ์ง๋ง JPQL์ ํญ์ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ SQL์ ์คํํด์ ๊ฒฐ๊ณผ๋ฅผ ์กฐํํ๋ค.
- ๋์ผํ ์ํฐํฐ๋ฅผ ์กฐํํ ๋๋ง๋ค ๋ฐ์ดํฐ๋ฒ ์ด์ค์์ ์กฐํํ์ง๋ง, ์ฒซ ์กฐํ ์ดํ ํด๋น ์ํฐํฐ๊ฐ ์์์ฑ ์ปจํ ์คํธ์ ๋ฑ๋ก๋์ด ์๊ธฐ ๋๋ฌธ์, ์์์ ์ธ๊ธํ ์ ์ฑ ์ ๋ฐ๋ผ ๋ฐ์ดํฐ๋ฒ ์ด์ค์์ ์กฐํํ ์ํฐํฐ๋ฅผ ๋ฒ๋ฆฌ๊ณ , ๊ธฐ์กด ์ํฐํฐ๋ฅผ ๋ฐํํ๋ค.
โฐ JPQL๊ณผ ํ๋ฌ์ ๋ชจ๋
ํ๋ฌ์
- ์์์ฑ ์ปจํ ์คํธ์ ๋ณ๊ฒฝ ๋ด์ญ์ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ๋๊ธฐํํ๋ ๊ฒ์ด๋ค.
- JPA๋ ํ๋ฌ์๊ฐ ์ผ์ด๋ ๋ ์์์ฑ ์ปจํ ์คํธ์ ๋ฑ๋ก, ์์ , ์ญ์ ํ ์ํฐํฐ๋ฅผ ์ฐพ์ SQL์ ๋ง๋ค๊ณ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ๋ฐ์ํ๋ค.
- ํ๋ฌ์ ํธ์ถ ๋ฉ์๋๊ฐ ์์ง๋ง, ๋ณดํต ํ๋ฌ์ ๋ชจ๋์ ๋ฐ๋ผ ์ปค๋ฐ ์ง์ ์ด๋ ์ฟผ๋ฆฌ ์คํ ์ง์ ์ ์๋์ผ๋ก ํธ์ถ๋๋ค.
ํ๋ฌ์ ๋ชจ๋๋ FlushModeType.AUTO ๊ฐ ๊ธฐ๋ณธ๊ฐ์ด๋ค.
- ๋ฐ๋ผ์ ํธ๋์ญ์ ์ปค๋ฐ ์ง์ ์ด๋ ์ฟผ๋ฆฌ ์คํ ์ง์ ์ ์๋์ผ๋ก ํ๋ฌ์๋ฅผ ํธ์ถํ๋ค.
-
๋ค๋ฅธ ์ต์ ์ผ๋ก๋
FlushModeType.COMMIT์ด ์๋๋ฐ, ์ด๋ ์ปค๋ฐ ์์๋ง ํ๋ฌ์๋ฅผ ํธ์ถํ๊ณ ์ฟผ๋ฆฌ ์คํ ์์๋ ํ๋ฌ์๋ฅผ ํธ์ถํ์ง ์๋๋ค.- ์ด ์ต์ ์ ์ฑ๋ฅ ์ต์ ํ๋ฅผ ์ํด ๊ผญ ํ์ํ ๋๋ง ์ฌ์ฉํ๋๋ก ํ๋ค.
๐ ์ฟผ๋ฆฌ์ ํ๋ฌ์ ๋ชจ๋
JPQL์ ์์์ฑ ์ปจํ
์คํธ์ ์๋ ๋ฐ์ดํฐ๋ฅผ ๊ณ ๋ คํ์ง ์๊ณ ๋ฐ์ดํฐ๋ฒ ์ด์ค์์ ์กฐํํ๋ค.
- ๋ฐ๋ผ์ JPQL์ ์คํํ๊ธฐ ์ ์์์ฑ ์ปจํ ์คํธ์ ๋ด์ฉ์ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ๋ฐ์ํด์ผ ํ๋ค.
-
๊ทธ๋ ์ง ์์ผ๋ฉด(
FlushModeType.COMMIT์ธ ๊ฒฝ์ฐ) ์์์ฑ ์ปจํ ์คํธ์๋ ์์ ๋ ์ํฐํฐ์ ๋ด์ฉ์ด ๋ฐ์ดํฐ๋ฒ ์ด์ค์๋ ๋ฐ์๋์ง ์์ ์์น ์๋ ๊ฒฐ๊ณผ๋ฅผ ๋ง๋๊ฒ ๋๋ค.setFlushMode()๋ฉ์๋๋ก ํ๋ฌ์ ๋ชจ๋๋ฅผ ์ค์ ํด์ค ์ ์๋ค.
๐ ํ๋ฌ์ ๋ชจ๋์ ์ต์ ํ
๊ทธ๋ ๋ค๋ฉด COMMIT ๋ชจ๋๋ ์ ์ฌ์ฉํ๋ ๊ฒ์ผ๊น?
- ์๋ชปํ๋ฉด ๋ฐ์ดํฐ ๋ฌด๊ฒฐ์ฑ์ ์ฌ๊ฐํ ํผํด๋ฅผ ์ค ์ ์๋ ์ํ์ด ์๋ ๋ชจ๋๋ผ ์๊ฐ๋๋ค.
- ํ์ง๋ง, ํ๋ฌ์๋ฅผ ๋๋ฌด ์์ฃผ ์ผ์ผํค๋ ์ํฉ์ ์ด ๋ชจ๋๋ฅผ ์ฌ์ฉํ๋ฉด, ์ฟผ๋ฆฌ ์ ๋ฐ์ํ๋ ํ๋ฌ์ ํ์๋ฅผ ์ค์ฌ ์ฑ๋ฅ ์ต์ ํ์ ๋์์ด ๋ ์ ์๋ค.
๋ํ, JPA๋ฅผ ์ฌ์ฉํ์ง ์๊ณ , JDBC๋ฅผ ์ง์ ์ฌ์ฉํด์ SQL์ ์คํํ ๋๋ ํ๋ฌ์ ๋ชจ๋๋ฅผ ๊ณ ๋ฏผํด์ผ ํ๋ค.
-
JPA๋ฅผ ํตํ์ง ์๊ณ ์ง์ ์ฟผ๋ฆฌ๋ฅผ ์คํํ๋ฉด JPA๋ JDBC๊ฐ ์คํํ ์ฟผ๋ฆฌ๋ฅผ ์ธ์ํ ๋ฐฉ๋ฒ์ด ์๋ค.
- ๋ฐ๋ผ์ ๋ณ๋์ JDBC ํธ์ถ์ ํ๋ฌ์ ๋ชจ๋๋ฅผ
AUTO์ค์ ํด๋ ํ๋ฌ์๊ฐ ๋ฐ์ํ์ง ์๋๋ค.
- ๋ฐ๋ผ์ ๋ณ๋์ JDBC ํธ์ถ์ ํ๋ฌ์ ๋ชจ๋๋ฅผ
- ์ด๋, ์ฟผ๋ฆฌ ์คํ ์ง์ ์
em.flush()๋ฅผ ํธ์ถํด ๋ด์ฉ์ ๋๊ธฐํํ๋ ๊ฒ์ด ์์ ํ๋ค.
๐ ์ถ์ฒ
์๋ฐ ORM ํ์ค JPA ํ๋ก๊ทธ๋๋ฐ - ๊น์ํ